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_SetLayoutingRequired(void * jarg1, bool jarg2) {
68679   Dali::Toolkit::Control *arg1 = 0 ;
68680
68681   arg1 = (Dali::Toolkit::Control *)jarg1;
68682   if (!arg1) {
68683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68684     return ;
68685   }
68686
68687   {
68688     try {
68689       Dali::Toolkit::DevelControl::SetLayoutingRequired(*arg1,jarg2);
68690     } catch (std::out_of_range& e) {
68691       {
68692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68693       };
68694     } catch (std::exception& e) {
68695       {
68696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68697       };
68698     } catch (...) {
68699       {
68700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68701       };
68702     }
68703   }
68704 }
68705
68706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_IsLayoutingRequired(void * jarg1) {
68707   unsigned int jresult ;
68708   Dali::Toolkit::Control *arg1 = 0 ;
68709   bool result;
68710
68711   arg1 = (Dali::Toolkit::Control *)jarg1;
68712   if (!arg1) {
68713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68714     return 0;
68715   }
68716   {
68717     try {
68718       result = (bool)DevelControl::IsLayoutingRequired( *arg1 );
68719     } catch (std::out_of_range& e) {
68720       {
68721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68722       };
68723     } catch (std::exception& e) {
68724       {
68725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68726       };
68727     } catch (Dali::DaliException e) {
68728       {
68729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68730       };
68731     } catch (...) {
68732       {
68733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68734       };
68735     }
68736   }
68737
68738   jresult = result;
68739   return jresult;
68740 }
68741
68742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68743   void * jresult ;
68744   Dali::Toolkit::Control *arg1 = 0 ;
68745   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68746
68747   arg1 = (Dali::Toolkit::Control *)jarg1;
68748   if (!arg1) {
68749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68750     return 0;
68751   }
68752   {
68753     try {
68754       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68755     } catch (std::out_of_range& e) {
68756       {
68757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68758       };
68759     } catch (std::exception& e) {
68760       {
68761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68762       };
68763     } catch (Dali::DaliException e) {
68764       {
68765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68766       };
68767     } catch (...) {
68768       {
68769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68770       };
68771     }
68772   }
68773
68774   jresult = (void *)result;
68775   return jresult;
68776 }
68777
68778
68779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68780   unsigned int jresult ;
68781   Dali::Toolkit::Control *arg1 = 0 ;
68782   bool result;
68783
68784   arg1 = (Dali::Toolkit::Control *)jarg1;
68785   if (!arg1) {
68786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68787     return 0;
68788   }
68789   {
68790     try {
68791       result = (bool)arg1->IsResourceReady();
68792     } catch (std::out_of_range& e) {
68793       {
68794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68795       };
68796     } catch (std::exception& e) {
68797       {
68798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68799       };
68800     } catch (Dali::DaliException e) {
68801       {
68802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68803       };
68804     } catch (...) {
68805       {
68806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68807       };
68808     }
68809   }
68810
68811   jresult = result;
68812   return jresult;
68813 }
68814
68815
68816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68817   void * jresult ;
68818   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68819
68820   {
68821     try {
68822       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68823     } catch (std::out_of_range& e) {
68824       {
68825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68826       };
68827     } catch (std::exception& e) {
68828       {
68829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68830       };
68831     } catch (Dali::DaliException e) {
68832       {
68833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68834       };
68835     } catch (...) {
68836       {
68837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68838       };
68839     }
68840   }
68841
68842   jresult = (void *)result;
68843   return jresult;
68844 }
68845
68846
68847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68848   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68849
68850   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68851   {
68852     try {
68853       delete arg1;
68854     } catch (std::out_of_range& e) {
68855       {
68856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68857       };
68858     } catch (std::exception& e) {
68859       {
68860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68861       };
68862     } catch (Dali::DaliException e) {
68863       {
68864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68865       };
68866     } catch (...) {
68867       {
68868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68869       };
68870     }
68871   }
68872
68873 }
68874
68875
68876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68877   void * jresult ;
68878   Dali::Toolkit::KeyInputFocusManager result;
68879
68880   {
68881     try {
68882       result = Dali::Toolkit::KeyInputFocusManager::Get();
68883     } catch (std::out_of_range& e) {
68884       {
68885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68886       };
68887     } catch (std::exception& e) {
68888       {
68889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68890       };
68891     } catch (Dali::DaliException e) {
68892       {
68893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68894       };
68895     } catch (...) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68898       };
68899     }
68900   }
68901
68902   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68903   return jresult;
68904 }
68905
68906
68907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68908   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68909   Dali::Toolkit::Control arg2 ;
68910   Dali::Toolkit::Control *argp2 ;
68911
68912   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68913   argp2 = (Dali::Toolkit::Control *)jarg2;
68914   if (!argp2) {
68915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68916     return ;
68917   }
68918   arg2 = *argp2;
68919   {
68920     try {
68921       (arg1)->SetFocus(arg2);
68922     } catch (std::out_of_range& e) {
68923       {
68924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68925       };
68926     } catch (std::exception& e) {
68927       {
68928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68929       };
68930     } catch (Dali::DaliException e) {
68931       {
68932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68933       };
68934     } catch (...) {
68935       {
68936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68937       };
68938     }
68939   }
68940
68941 }
68942
68943
68944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68945   void * jresult ;
68946   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68947   Dali::Toolkit::Control result;
68948
68949   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68950   {
68951     try {
68952       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68953     } catch (std::out_of_range& e) {
68954       {
68955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68956       };
68957     } catch (std::exception& e) {
68958       {
68959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68960       };
68961     } catch (Dali::DaliException e) {
68962       {
68963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68964       };
68965     } catch (...) {
68966       {
68967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68968       };
68969     }
68970   }
68971
68972   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68978   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68979   Dali::Toolkit::Control arg2 ;
68980   Dali::Toolkit::Control *argp2 ;
68981
68982   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68983   argp2 = (Dali::Toolkit::Control *)jarg2;
68984   if (!argp2) {
68985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68986     return ;
68987   }
68988   arg2 = *argp2;
68989   {
68990     try {
68991       (arg1)->RemoveFocus(arg2);
68992     } catch (std::out_of_range& e) {
68993       {
68994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68995       };
68996     } catch (std::exception& e) {
68997       {
68998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68999       };
69000     } catch (Dali::DaliException e) {
69001       {
69002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69003       };
69004     } catch (...) {
69005       {
69006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69007       };
69008     }
69009   }
69010
69011 }
69012
69013
69014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69015   void * jresult ;
69016   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69017   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69018
69019   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69020   {
69021     try {
69022       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69023     } catch (std::out_of_range& e) {
69024       {
69025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69026       };
69027     } catch (std::exception& e) {
69028       {
69029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69030       };
69031     } catch (Dali::DaliException e) {
69032       {
69033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69034       };
69035     } catch (...) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69038       };
69039     }
69040   }
69041
69042   jresult = (void *)result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69048   void * jresult ;
69049   Dali::Toolkit::Alignment::Padding *result = 0 ;
69050
69051   {
69052     try {
69053       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69054     } catch (std::out_of_range& e) {
69055       {
69056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69057       };
69058     } catch (std::exception& e) {
69059       {
69060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69061       };
69062     } catch (Dali::DaliException e) {
69063       {
69064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69065       };
69066     } catch (...) {
69067       {
69068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69069       };
69070     }
69071   }
69072
69073   jresult = (void *)result;
69074   return jresult;
69075 }
69076
69077
69078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69079   void * jresult ;
69080   float arg1 ;
69081   float arg2 ;
69082   float arg3 ;
69083   float arg4 ;
69084   Dali::Toolkit::Alignment::Padding *result = 0 ;
69085
69086   arg1 = (float)jarg1;
69087   arg2 = (float)jarg2;
69088   arg3 = (float)jarg3;
69089   arg4 = (float)jarg4;
69090   {
69091     try {
69092       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69093     } catch (std::out_of_range& e) {
69094       {
69095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69096       };
69097     } catch (std::exception& e) {
69098       {
69099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69100       };
69101     } catch (Dali::DaliException e) {
69102       {
69103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69104       };
69105     } catch (...) {
69106       {
69107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69108       };
69109     }
69110   }
69111
69112   jresult = (void *)result;
69113   return jresult;
69114 }
69115
69116
69117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69118   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69119   float arg2 ;
69120
69121   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69122   arg2 = (float)jarg2;
69123   if (arg1) (arg1)->left = arg2;
69124 }
69125
69126
69127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69128   float jresult ;
69129   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69130   float result;
69131
69132   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69133   result = (float) ((arg1)->left);
69134   jresult = result;
69135   return jresult;
69136 }
69137
69138
69139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69140   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69141   float arg2 ;
69142
69143   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69144   arg2 = (float)jarg2;
69145   if (arg1) (arg1)->right = arg2;
69146 }
69147
69148
69149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69150   float jresult ;
69151   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69152   float result;
69153
69154   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69155   result = (float) ((arg1)->right);
69156   jresult = result;
69157   return jresult;
69158 }
69159
69160
69161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69162   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69163   float arg2 ;
69164
69165   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69166   arg2 = (float)jarg2;
69167   if (arg1) (arg1)->top = arg2;
69168 }
69169
69170
69171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69172   float jresult ;
69173   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69174   float result;
69175
69176   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69177   result = (float) ((arg1)->top);
69178   jresult = result;
69179   return jresult;
69180 }
69181
69182
69183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69184   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69185   float arg2 ;
69186
69187   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69188   arg2 = (float)jarg2;
69189   if (arg1) (arg1)->bottom = arg2;
69190 }
69191
69192
69193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69194   float jresult ;
69195   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69196   float result;
69197
69198   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69199   result = (float) ((arg1)->bottom);
69200   jresult = result;
69201   return jresult;
69202 }
69203
69204
69205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69206   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69207
69208   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69209   {
69210     try {
69211       delete arg1;
69212     } catch (std::out_of_range& e) {
69213       {
69214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69215       };
69216     } catch (std::exception& e) {
69217       {
69218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69219       };
69220     } catch (Dali::DaliException e) {
69221       {
69222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69223       };
69224     } catch (...) {
69225       {
69226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69227       };
69228     }
69229   }
69230
69231 }
69232
69233
69234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69235   void * jresult ;
69236   Dali::Toolkit::Alignment *result = 0 ;
69237
69238   {
69239     try {
69240       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69241     } catch (std::out_of_range& e) {
69242       {
69243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69244       };
69245     } catch (std::exception& e) {
69246       {
69247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69248       };
69249     } catch (Dali::DaliException e) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69256       };
69257     }
69258   }
69259
69260   jresult = (void *)result;
69261   return jresult;
69262 }
69263
69264
69265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69266   void * jresult ;
69267   Dali::Toolkit::Alignment::Type arg1 ;
69268   Dali::Toolkit::Alignment::Type arg2 ;
69269   Dali::Toolkit::Alignment result;
69270
69271   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69272   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69273   {
69274     try {
69275       result = Dali::Toolkit::Alignment::New(arg1,arg2);
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_Alignment_New__SWIG_1(int jarg1) {
69301   void * jresult ;
69302   Dali::Toolkit::Alignment::Type arg1 ;
69303   Dali::Toolkit::Alignment result;
69304
69305   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69306   {
69307     try {
69308       result = Dali::Toolkit::Alignment::New(arg1);
69309     } catch (std::out_of_range& e) {
69310       {
69311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69312       };
69313     } catch (std::exception& e) {
69314       {
69315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69316       };
69317     } catch (Dali::DaliException e) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69320       };
69321     } catch (...) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69324       };
69325     }
69326   }
69327
69328   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69329   return jresult;
69330 }
69331
69332
69333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69334   void * jresult ;
69335   Dali::Toolkit::Alignment result;
69336
69337   {
69338     try {
69339       result = Dali::Toolkit::Alignment::New();
69340     } catch (std::out_of_range& e) {
69341       {
69342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69343       };
69344     } catch (std::exception& e) {
69345       {
69346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69347       };
69348     } catch (Dali::DaliException e) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69351       };
69352     } catch (...) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69355       };
69356     }
69357   }
69358
69359   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69360   return jresult;
69361 }
69362
69363
69364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69365   void * jresult ;
69366   Dali::Toolkit::Alignment *arg1 = 0 ;
69367   Dali::Toolkit::Alignment *result = 0 ;
69368
69369   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69370   if (!arg1) {
69371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69372     return 0;
69373   }
69374   {
69375     try {
69376       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69377     } catch (std::out_of_range& e) {
69378       {
69379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69380       };
69381     } catch (std::exception& e) {
69382       {
69383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69384       };
69385     } catch (Dali::DaliException e) {
69386       {
69387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69388       };
69389     } catch (...) {
69390       {
69391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69392       };
69393     }
69394   }
69395
69396   jresult = (void *)result;
69397   return jresult;
69398 }
69399
69400
69401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69402   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69403
69404   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69405   {
69406     try {
69407       delete arg1;
69408     } catch (std::out_of_range& e) {
69409       {
69410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69411       };
69412     } catch (std::exception& e) {
69413       {
69414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69415       };
69416     } catch (Dali::DaliException e) {
69417       {
69418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69419       };
69420     } catch (...) {
69421       {
69422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69423       };
69424     }
69425   }
69426
69427 }
69428
69429
69430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69431   void * jresult ;
69432   Dali::BaseHandle arg1 ;
69433   Dali::BaseHandle *argp1 ;
69434   Dali::Toolkit::Alignment result;
69435
69436   argp1 = (Dali::BaseHandle *)jarg1;
69437   if (!argp1) {
69438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69439     return 0;
69440   }
69441   arg1 = *argp1;
69442   {
69443     try {
69444       result = Dali::Toolkit::Alignment::DownCast(arg1);
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 = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69465   return jresult;
69466 }
69467
69468
69469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69470   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69471   Dali::Toolkit::Alignment::Type arg2 ;
69472
69473   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69474   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69475   {
69476     try {
69477       (arg1)->SetAlignmentType(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_GetAlignmentType(void * jarg1) {
69501   int jresult ;
69502   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69503   Dali::Toolkit::Alignment::Type result;
69504
69505   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69506   {
69507     try {
69508       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
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_SetScaling(void * jarg1, int jarg2) {
69534   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69535   Dali::Toolkit::Alignment::Scaling arg2 ;
69536
69537   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69538   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69539   {
69540     try {
69541       (arg1)->SetScaling(arg2);
69542     } catch (std::out_of_range& e) {
69543       {
69544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69545       };
69546     } catch (std::exception& e) {
69547       {
69548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69549       };
69550     } catch (Dali::DaliException e) {
69551       {
69552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69553       };
69554     } catch (...) {
69555       {
69556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69557       };
69558     }
69559   }
69560
69561 }
69562
69563
69564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69565   int jresult ;
69566   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69567   Dali::Toolkit::Alignment::Scaling result;
69568
69569   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69570   {
69571     try {
69572       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69573     } catch (std::out_of_range& e) {
69574       {
69575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (std::exception& e) {
69578       {
69579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69580       };
69581     } catch (Dali::DaliException e) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69584       };
69585     } catch (...) {
69586       {
69587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69588       };
69589     }
69590   }
69591
69592   jresult = (int)result;
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69598   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69599   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69600
69601   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69602   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69603   if (!arg2) {
69604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69605     return ;
69606   }
69607   {
69608     try {
69609       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69610     } catch (std::out_of_range& e) {
69611       {
69612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69613       };
69614     } catch (std::exception& e) {
69615       {
69616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69617       };
69618     } catch (Dali::DaliException e) {
69619       {
69620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69621       };
69622     } catch (...) {
69623       {
69624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69625       };
69626     }
69627   }
69628
69629 }
69630
69631
69632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69633   void * jresult ;
69634   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69635   Dali::Toolkit::Alignment::Padding *result = 0 ;
69636
69637   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69638   {
69639     try {
69640       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69641     } catch (std::out_of_range& e) {
69642       {
69643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (std::exception& e) {
69646       {
69647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69648       };
69649     } catch (Dali::DaliException e) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69652       };
69653     } catch (...) {
69654       {
69655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69656       };
69657     }
69658   }
69659
69660   jresult = (void *)result;
69661   return jresult;
69662 }
69663
69664
69665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69666   void * jresult ;
69667   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69668   Dali::Toolkit::Alignment *arg2 = 0 ;
69669   Dali::Toolkit::Alignment *result = 0 ;
69670
69671   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69672   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69673   if (!arg2) {
69674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69675     return 0;
69676   }
69677   {
69678     try {
69679       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69680     } catch (std::out_of_range& e) {
69681       {
69682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69683       };
69684     } catch (std::exception& e) {
69685       {
69686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69687       };
69688     } catch (Dali::DaliException e) {
69689       {
69690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69691       };
69692     } catch (...) {
69693       {
69694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69695       };
69696     }
69697   }
69698
69699   jresult = (void *)result;
69700   return jresult;
69701 }
69702
69703
69704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69705   int jresult ;
69706   int result;
69707
69708   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69709   jresult = (int)result;
69710   return jresult;
69711 }
69712
69713
69714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69715   int jresult ;
69716   int result;
69717
69718   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69719   jresult = (int)result;
69720   return jresult;
69721 }
69722
69723
69724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69725   int jresult ;
69726   int result;
69727
69728   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69729   jresult = (int)result;
69730   return jresult;
69731 }
69732
69733
69734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69735   int jresult ;
69736   int result;
69737
69738   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69739   jresult = (int)result;
69740   return jresult;
69741 }
69742
69743
69744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69745   int jresult ;
69746   int result;
69747
69748   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69749   jresult = (int)result;
69750   return jresult;
69751 }
69752
69753
69754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69755   int jresult ;
69756   int result;
69757
69758   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69759   jresult = (int)result;
69760   return jresult;
69761 }
69762
69763
69764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69765   int jresult ;
69766   int result;
69767
69768   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69769   jresult = (int)result;
69770   return jresult;
69771 }
69772
69773
69774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69775   int jresult ;
69776   int result;
69777
69778   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69779   jresult = (int)result;
69780   return jresult;
69781 }
69782
69783
69784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69785   int jresult ;
69786   int result;
69787
69788   result = (int)Dali::Toolkit::Button::Property::LABEL;
69789   jresult = (int)result;
69790   return jresult;
69791 }
69792
69793
69794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69795   int jresult ;
69796   int result;
69797
69798   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69799   jresult = (int)result;
69800   return jresult;
69801 }
69802
69803
69804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69805   void * jresult ;
69806   Dali::Toolkit::Button::Property *result = 0 ;
69807
69808   {
69809     try {
69810       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69811     } catch (std::out_of_range& e) {
69812       {
69813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69814       };
69815     } catch (std::exception& e) {
69816       {
69817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69818       };
69819     } catch (Dali::DaliException e) {
69820       {
69821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69822       };
69823     } catch (...) {
69824       {
69825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69826       };
69827     }
69828   }
69829
69830   jresult = (void *)result;
69831   return jresult;
69832 }
69833
69834
69835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69836   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69837
69838   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69839   {
69840     try {
69841       delete arg1;
69842     } catch (std::out_of_range& e) {
69843       {
69844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69845       };
69846     } catch (std::exception& e) {
69847       {
69848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69849       };
69850     } catch (Dali::DaliException e) {
69851       {
69852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69853       };
69854     } catch (...) {
69855       {
69856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69857       };
69858     }
69859   }
69860
69861 }
69862
69863
69864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69865   void * jresult ;
69866   Dali::Toolkit::Button *result = 0 ;
69867
69868   {
69869     try {
69870       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69871     } catch (std::out_of_range& e) {
69872       {
69873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69874       };
69875     } catch (std::exception& e) {
69876       {
69877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (Dali::DaliException e) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69882       };
69883     } catch (...) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69886       };
69887     }
69888   }
69889
69890   jresult = (void *)result;
69891   return jresult;
69892 }
69893
69894
69895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69896   void * jresult ;
69897   Dali::Toolkit::Button *arg1 = 0 ;
69898   Dali::Toolkit::Button *result = 0 ;
69899
69900   arg1 = (Dali::Toolkit::Button *)jarg1;
69901   if (!arg1) {
69902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69903     return 0;
69904   }
69905   {
69906     try {
69907       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69908     } catch (std::out_of_range& e) {
69909       {
69910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69911       };
69912     } catch (std::exception& e) {
69913       {
69914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69915       };
69916     } catch (Dali::DaliException e) {
69917       {
69918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69919       };
69920     } catch (...) {
69921       {
69922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69923       };
69924     }
69925   }
69926
69927   jresult = (void *)result;
69928   return jresult;
69929 }
69930
69931
69932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69933   void * jresult ;
69934   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69935   Dali::Toolkit::Button *arg2 = 0 ;
69936   Dali::Toolkit::Button *result = 0 ;
69937
69938   arg1 = (Dali::Toolkit::Button *)jarg1;
69939   arg2 = (Dali::Toolkit::Button *)jarg2;
69940   if (!arg2) {
69941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69942     return 0;
69943   }
69944   {
69945     try {
69946       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69947     } catch (std::out_of_range& e) {
69948       {
69949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69950       };
69951     } catch (std::exception& e) {
69952       {
69953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69954       };
69955     } catch (Dali::DaliException e) {
69956       {
69957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69958       };
69959     } catch (...) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69962       };
69963     }
69964   }
69965
69966   jresult = (void *)result;
69967   return jresult;
69968 }
69969
69970
69971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69972   void * jresult ;
69973   Dali::BaseHandle arg1 ;
69974   Dali::BaseHandle *argp1 ;
69975   Dali::Toolkit::Button result;
69976
69977   argp1 = (Dali::BaseHandle *)jarg1;
69978   if (!argp1) {
69979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69980     return 0;
69981   }
69982   arg1 = *argp1;
69983   {
69984     try {
69985       result = Dali::Toolkit::Button::DownCast(arg1);
69986     } catch (std::out_of_range& e) {
69987       {
69988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69989       };
69990     } catch (std::exception& e) {
69991       {
69992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69993       };
69994     } catch (Dali::DaliException e) {
69995       {
69996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69997       };
69998     } catch (...) {
69999       {
70000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70001       };
70002     }
70003   }
70004
70005   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70006   return jresult;
70007 }
70008
70009
70010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70011   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70012
70013   arg1 = (Dali::Toolkit::Button *)jarg1;
70014   {
70015     try {
70016       delete arg1;
70017     } catch (std::out_of_range& e) {
70018       {
70019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70020       };
70021     } catch (std::exception& e) {
70022       {
70023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70024       };
70025     } catch (Dali::DaliException e) {
70026       {
70027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70028       };
70029     } catch (...) {
70030       {
70031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70032       };
70033     }
70034   }
70035
70036 }
70037
70038
70039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70040   unsigned int jresult ;
70041   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70042   bool result;
70043
70044   arg1 = (Dali::Toolkit::Button *)jarg1;
70045   {
70046     try {
70047       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70048     } catch (std::out_of_range& e) {
70049       {
70050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70051       };
70052     } catch (std::exception& e) {
70053       {
70054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70055       };
70056     } catch (Dali::DaliException e) {
70057       {
70058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70059       };
70060     } catch (...) {
70061       {
70062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70063       };
70064     }
70065   }
70066
70067   jresult = result;
70068   return jresult;
70069 }
70070
70071
70072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70073   unsigned int jresult ;
70074   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70075   bool result;
70076
70077   arg1 = (Dali::Toolkit::Button *)jarg1;
70078   {
70079     try {
70080       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70081     } catch (std::out_of_range& e) {
70082       {
70083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70084       };
70085     } catch (std::exception& e) {
70086       {
70087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70088       };
70089     } catch (Dali::DaliException e) {
70090       {
70091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70092       };
70093     } catch (...) {
70094       {
70095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70096       };
70097     }
70098   }
70099
70100   jresult = result;
70101   return jresult;
70102 }
70103
70104
70105 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70106   float jresult ;
70107   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70108   float result;
70109
70110   arg1 = (Dali::Toolkit::Button *)jarg1;
70111   {
70112     try {
70113       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70114     } catch (std::out_of_range& e) {
70115       {
70116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (std::exception& e) {
70119       {
70120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70121       };
70122     } catch (Dali::DaliException e) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70125       };
70126     } catch (...) {
70127       {
70128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70129       };
70130     }
70131   }
70132
70133   jresult = result;
70134   return jresult;
70135 }
70136
70137
70138 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70139   float jresult ;
70140   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70141   float result;
70142
70143   arg1 = (Dali::Toolkit::Button *)jarg1;
70144   {
70145     try {
70146       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70147     } catch (std::out_of_range& e) {
70148       {
70149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70150       };
70151     } catch (std::exception& e) {
70152       {
70153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70154       };
70155     } catch (Dali::DaliException e) {
70156       {
70157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70158       };
70159     } catch (...) {
70160       {
70161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70162       };
70163     }
70164   }
70165
70166   jresult = result;
70167   return jresult;
70168 }
70169
70170
70171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70172   unsigned int jresult ;
70173   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70174   bool result;
70175
70176   arg1 = (Dali::Toolkit::Button *)jarg1;
70177   {
70178     try {
70179       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70180     } catch (std::out_of_range& e) {
70181       {
70182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70183       };
70184     } catch (std::exception& e) {
70185       {
70186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70187       };
70188     } catch (Dali::DaliException e) {
70189       {
70190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70191       };
70192     } catch (...) {
70193       {
70194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70195       };
70196     }
70197   }
70198
70199   jresult = result;
70200   return jresult;
70201 }
70202
70203
70204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70205   unsigned int jresult ;
70206   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70207   bool result;
70208
70209   arg1 = (Dali::Toolkit::Button *)jarg1;
70210   {
70211     try {
70212       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70213     } catch (std::out_of_range& e) {
70214       {
70215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70216       };
70217     } catch (std::exception& e) {
70218       {
70219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70220       };
70221     } catch (Dali::DaliException e) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70224       };
70225     } catch (...) {
70226       {
70227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70228       };
70229     }
70230   }
70231
70232   jresult = result;
70233   return jresult;
70234 }
70235
70236
70237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70238   float jresult ;
70239   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70240   float result;
70241
70242   arg1 = (Dali::Toolkit::Button *)jarg1;
70243   {
70244     try {
70245       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70253       };
70254     } catch (Dali::DaliException e) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70261       };
70262     }
70263   }
70264
70265   jresult = result;
70266   return jresult;
70267 }
70268
70269
70270 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70271   char * jresult ;
70272   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70273   std::string result;
70274
70275   arg1 = (Dali::Toolkit::Button *)jarg1;
70276   {
70277     try {
70278       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70279     } catch (std::out_of_range& e) {
70280       {
70281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70282       };
70283     } catch (std::exception& e) {
70284       {
70285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70286       };
70287     } catch (Dali::DaliException e) {
70288       {
70289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70290       };
70291     } catch (...) {
70292       {
70293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70294       };
70295     }
70296   }
70297
70298   jresult = SWIG_csharp_string_callback((&result)->c_str());
70299   return jresult;
70300 }
70301
70302
70303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70304   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70305   Dali::Actor arg2 ;
70306   Dali::Actor *argp2 ;
70307
70308   arg1 = (Dali::Toolkit::Button *)jarg1;
70309   argp2 = (Dali::Actor *)jarg2;
70310   if (!argp2) {
70311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70312     return ;
70313   }
70314   arg2 = *argp2;
70315   {
70316     try {
70317       (arg1)->SetLabel(arg2);
70318     } catch (std::out_of_range& e) {
70319       {
70320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70321       };
70322     } catch (std::exception& e) {
70323       {
70324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70325       };
70326     } catch (Dali::DaliException e) {
70327       {
70328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70329       };
70330     } catch (...) {
70331       {
70332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70333       };
70334     }
70335   }
70336
70337 }
70338
70339
70340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70341   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70342   Dali::Image arg2 ;
70343   Dali::Image *argp2 ;
70344
70345   arg1 = (Dali::Toolkit::Button *)jarg1;
70346   argp2 = (Dali::Image *)jarg2;
70347   if (!argp2) {
70348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70349     return ;
70350   }
70351   arg2 = *argp2;
70352   {
70353     try {
70354       (arg1)->SetButtonImage(arg2);
70355     } catch (std::out_of_range& e) {
70356       {
70357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70358       };
70359     } catch (std::exception& e) {
70360       {
70361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70362       };
70363     } catch (Dali::DaliException e) {
70364       {
70365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70366       };
70367     } catch (...) {
70368       {
70369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70370       };
70371     }
70372   }
70373
70374 }
70375
70376
70377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70378   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70379   Dali::Image arg2 ;
70380   Dali::Image *argp2 ;
70381
70382   arg1 = (Dali::Toolkit::Button *)jarg1;
70383   argp2 = (Dali::Image *)jarg2;
70384   if (!argp2) {
70385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70386     return ;
70387   }
70388   arg2 = *argp2;
70389   {
70390     try {
70391       (arg1)->SetSelectedImage(arg2);
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70399       };
70400     } catch (Dali::DaliException e) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70403       };
70404     } catch (...) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70407       };
70408     }
70409   }
70410
70411 }
70412
70413
70414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70415   void * jresult ;
70416   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70417   Dali::Actor result;
70418
70419   arg1 = (Dali::Toolkit::Button *)jarg1;
70420   {
70421     try {
70422       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70423     } catch (std::out_of_range& e) {
70424       {
70425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (std::exception& e) {
70428       {
70429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70430       };
70431     } catch (Dali::DaliException e) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70434       };
70435     } catch (...) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70438       };
70439     }
70440   }
70441
70442   jresult = new Dali::Actor((const Dali::Actor &)result);
70443   return jresult;
70444 }
70445
70446
70447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70448   void * jresult ;
70449   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70450   Dali::Actor result;
70451
70452   arg1 = (Dali::Toolkit::Button *)jarg1;
70453   {
70454     try {
70455       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70456     } catch (std::out_of_range& e) {
70457       {
70458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70459       };
70460     } catch (std::exception& e) {
70461       {
70462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70463       };
70464     } catch (Dali::DaliException e) {
70465       {
70466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70467       };
70468     } catch (...) {
70469       {
70470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70471       };
70472     }
70473   }
70474
70475   jresult = new Dali::Actor((const Dali::Actor &)result);
70476   return jresult;
70477 }
70478
70479
70480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70481   void * jresult ;
70482   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70483   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70484
70485   arg1 = (Dali::Toolkit::Button *)jarg1;
70486   {
70487     try {
70488       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70489     } catch (std::out_of_range& e) {
70490       {
70491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70492       };
70493     } catch (std::exception& e) {
70494       {
70495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70496       };
70497     } catch (Dali::DaliException e) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70500       };
70501     } catch (...) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70504       };
70505     }
70506   }
70507
70508   jresult = (void *)result;
70509   return jresult;
70510 }
70511
70512
70513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70514   void * jresult ;
70515   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70516   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70517
70518   arg1 = (Dali::Toolkit::Button *)jarg1;
70519   {
70520     try {
70521       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70522     } catch (std::out_of_range& e) {
70523       {
70524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70525       };
70526     } catch (std::exception& e) {
70527       {
70528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70529       };
70530     } catch (Dali::DaliException e) {
70531       {
70532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70533       };
70534     } catch (...) {
70535       {
70536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70537       };
70538     }
70539   }
70540
70541   jresult = (void *)result;
70542   return jresult;
70543 }
70544
70545
70546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70547   void * jresult ;
70548   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70549   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70550
70551   arg1 = (Dali::Toolkit::Button *)jarg1;
70552   {
70553     try {
70554       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
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_Button_StateChangedSignal(void * jarg1) {
70580   void * jresult ;
70581   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70582   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70583
70584   arg1 = (Dali::Toolkit::Button *)jarg1;
70585   {
70586     try {
70587       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70588     } catch (std::out_of_range& e) {
70589       {
70590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70591       };
70592     } catch (std::exception& e) {
70593       {
70594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70595       };
70596     } catch (Dali::DaliException e) {
70597       {
70598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70599       };
70600     } catch (...) {
70601       {
70602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70603       };
70604     }
70605   }
70606
70607   jresult = (void *)result;
70608   return jresult;
70609 }
70610
70611
70612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70613   void * jresult ;
70614   Dali::Toolkit::CheckBoxButton *result = 0 ;
70615
70616   {
70617     try {
70618       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70619     } catch (std::out_of_range& e) {
70620       {
70621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70622       };
70623     } catch (std::exception& e) {
70624       {
70625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70626       };
70627     } catch (Dali::DaliException e) {
70628       {
70629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70630       };
70631     } catch (...) {
70632       {
70633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70634       };
70635     }
70636   }
70637
70638   jresult = (void *)result;
70639   return jresult;
70640 }
70641
70642
70643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70644   void * jresult ;
70645   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70646   Dali::Toolkit::CheckBoxButton *result = 0 ;
70647
70648   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70649   if (!arg1) {
70650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70651     return 0;
70652   }
70653   {
70654     try {
70655       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70656     } catch (std::out_of_range& e) {
70657       {
70658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70659       };
70660     } catch (std::exception& e) {
70661       {
70662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70663       };
70664     } catch (Dali::DaliException e) {
70665       {
70666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70667       };
70668     } catch (...) {
70669       {
70670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70671       };
70672     }
70673   }
70674
70675   jresult = (void *)result;
70676   return jresult;
70677 }
70678
70679
70680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70681   void * jresult ;
70682   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70683   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70684   Dali::Toolkit::CheckBoxButton *result = 0 ;
70685
70686   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70687   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70688   if (!arg2) {
70689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70690     return 0;
70691   }
70692   {
70693     try {
70694       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70695     } catch (std::out_of_range& e) {
70696       {
70697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70698       };
70699     } catch (std::exception& e) {
70700       {
70701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70702       };
70703     } catch (Dali::DaliException e) {
70704       {
70705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70706       };
70707     } catch (...) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70710       };
70711     }
70712   }
70713
70714   jresult = (void *)result;
70715   return jresult;
70716 }
70717
70718
70719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70720   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70721
70722   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70723   {
70724     try {
70725       delete arg1;
70726     } catch (std::out_of_range& e) {
70727       {
70728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70729       };
70730     } catch (std::exception& e) {
70731       {
70732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70733       };
70734     } catch (Dali::DaliException e) {
70735       {
70736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70737       };
70738     } catch (...) {
70739       {
70740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70741       };
70742     }
70743   }
70744
70745 }
70746
70747
70748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70749   void * jresult ;
70750   Dali::Toolkit::CheckBoxButton result;
70751
70752   {
70753     try {
70754       result = Dali::Toolkit::CheckBoxButton::New();
70755     } catch (std::out_of_range& e) {
70756       {
70757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70758       };
70759     } catch (std::exception& e) {
70760       {
70761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70762       };
70763     } catch (Dali::DaliException e) {
70764       {
70765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70766       };
70767     } catch (...) {
70768       {
70769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70770       };
70771     }
70772   }
70773
70774   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70775   return jresult;
70776 }
70777
70778
70779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70780   void * jresult ;
70781   Dali::BaseHandle arg1 ;
70782   Dali::BaseHandle *argp1 ;
70783   Dali::Toolkit::CheckBoxButton result;
70784
70785   argp1 = (Dali::BaseHandle *)jarg1;
70786   if (!argp1) {
70787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70788     return 0;
70789   }
70790   arg1 = *argp1;
70791   {
70792     try {
70793       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70794     } catch (std::out_of_range& e) {
70795       {
70796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70797       };
70798     } catch (std::exception& e) {
70799       {
70800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70801       };
70802     } catch (Dali::DaliException e) {
70803       {
70804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70805       };
70806     } catch (...) {
70807       {
70808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70809       };
70810     }
70811   }
70812
70813   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70814   return jresult;
70815 }
70816
70817
70818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70819   int jresult ;
70820   int result;
70821
70822   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70823   jresult = (int)result;
70824   return jresult;
70825 }
70826
70827
70828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70829   int jresult ;
70830   int result;
70831
70832   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70833   jresult = (int)result;
70834   return jresult;
70835 }
70836
70837
70838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70839   int jresult ;
70840   int result;
70841
70842   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70843   jresult = (int)result;
70844   return jresult;
70845 }
70846
70847
70848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70849   int jresult ;
70850   int result;
70851
70852   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70853   jresult = (int)result;
70854   return jresult;
70855 }
70856
70857
70858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70859   int jresult ;
70860   int result;
70861
70862   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70863   jresult = (int)result;
70864   return jresult;
70865 }
70866
70867
70868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70869   void * jresult ;
70870   Dali::Toolkit::PushButton::Property *result = 0 ;
70871
70872   {
70873     try {
70874       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70875     } catch (std::out_of_range& e) {
70876       {
70877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70878       };
70879     } catch (std::exception& e) {
70880       {
70881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70882       };
70883     } catch (Dali::DaliException e) {
70884       {
70885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70886       };
70887     } catch (...) {
70888       {
70889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70890       };
70891     }
70892   }
70893
70894   jresult = (void *)result;
70895   return jresult;
70896 }
70897
70898
70899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70900   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70901
70902   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70903   {
70904     try {
70905       delete arg1;
70906     } catch (std::out_of_range& e) {
70907       {
70908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70909       };
70910     } catch (std::exception& e) {
70911       {
70912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70913       };
70914     } catch (Dali::DaliException e) {
70915       {
70916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70917       };
70918     } catch (...) {
70919       {
70920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70921       };
70922     }
70923   }
70924
70925 }
70926
70927
70928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70929   void * jresult ;
70930   Dali::Toolkit::PushButton *result = 0 ;
70931
70932   {
70933     try {
70934       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70935     } catch (std::out_of_range& e) {
70936       {
70937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (std::exception& e) {
70940       {
70941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70942       };
70943     } catch (Dali::DaliException e) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70946       };
70947     } catch (...) {
70948       {
70949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70950       };
70951     }
70952   }
70953
70954   jresult = (void *)result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70960   void * jresult ;
70961   Dali::Toolkit::PushButton *arg1 = 0 ;
70962   Dali::Toolkit::PushButton *result = 0 ;
70963
70964   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70965   if (!arg1) {
70966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70967     return 0;
70968   }
70969   {
70970     try {
70971       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70972     } catch (std::out_of_range& e) {
70973       {
70974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70975       };
70976     } catch (std::exception& e) {
70977       {
70978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70979       };
70980     } catch (Dali::DaliException e) {
70981       {
70982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70983       };
70984     } catch (...) {
70985       {
70986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70987       };
70988     }
70989   }
70990
70991   jresult = (void *)result;
70992   return jresult;
70993 }
70994
70995
70996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70997   void * jresult ;
70998   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70999   Dali::Toolkit::PushButton *arg2 = 0 ;
71000   Dali::Toolkit::PushButton *result = 0 ;
71001
71002   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71003   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71004   if (!arg2) {
71005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71006     return 0;
71007   }
71008   {
71009     try {
71010       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71011     } catch (std::out_of_range& e) {
71012       {
71013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71014       };
71015     } catch (std::exception& e) {
71016       {
71017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71018       };
71019     } catch (Dali::DaliException e) {
71020       {
71021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71022       };
71023     } catch (...) {
71024       {
71025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71026       };
71027     }
71028   }
71029
71030   jresult = (void *)result;
71031   return jresult;
71032 }
71033
71034
71035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71036   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71037
71038   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71039   {
71040     try {
71041       delete arg1;
71042     } catch (std::out_of_range& e) {
71043       {
71044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71045       };
71046     } catch (std::exception& e) {
71047       {
71048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71049       };
71050     } catch (Dali::DaliException e) {
71051       {
71052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71053       };
71054     } catch (...) {
71055       {
71056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71057       };
71058     }
71059   }
71060
71061 }
71062
71063
71064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71065   void * jresult ;
71066   Dali::Toolkit::PushButton result;
71067
71068   {
71069     try {
71070       result = Dali::Toolkit::PushButton::New();
71071     } catch (std::out_of_range& e) {
71072       {
71073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71074       };
71075     } catch (std::exception& e) {
71076       {
71077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71078       };
71079     } catch (Dali::DaliException e) {
71080       {
71081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71082       };
71083     } catch (...) {
71084       {
71085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71086       };
71087     }
71088   }
71089
71090   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71091   return jresult;
71092 }
71093
71094
71095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71096   void * jresult ;
71097   Dali::BaseHandle arg1 ;
71098   Dali::BaseHandle *argp1 ;
71099   Dali::Toolkit::PushButton result;
71100
71101   argp1 = (Dali::BaseHandle *)jarg1;
71102   if (!argp1) {
71103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71104     return 0;
71105   }
71106   arg1 = *argp1;
71107   {
71108     try {
71109       result = Dali::Toolkit::PushButton::DownCast(arg1);
71110     } catch (std::out_of_range& e) {
71111       {
71112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71113       };
71114     } catch (std::exception& e) {
71115       {
71116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71117       };
71118     } catch (Dali::DaliException e) {
71119       {
71120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71121       };
71122     } catch (...) {
71123       {
71124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71125       };
71126     }
71127   }
71128
71129   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71130   return jresult;
71131 }
71132
71133
71134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71135   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71136   Dali::Image arg2 ;
71137   Dali::Image *argp2 ;
71138
71139   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71140   argp2 = (Dali::Image *)jarg2;
71141   if (!argp2) {
71142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71143     return ;
71144   }
71145   arg2 = *argp2;
71146   {
71147     try {
71148       (arg1)->SetButtonImage(arg2);
71149     } catch (std::out_of_range& e) {
71150       {
71151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71152       };
71153     } catch (std::exception& e) {
71154       {
71155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71156       };
71157     } catch (Dali::DaliException e) {
71158       {
71159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71160       };
71161     } catch (...) {
71162       {
71163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71164       };
71165     }
71166   }
71167
71168 }
71169
71170
71171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71172   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71173   Dali::Actor arg2 ;
71174   Dali::Actor *argp2 ;
71175
71176   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71177   argp2 = (Dali::Actor *)jarg2;
71178   if (!argp2) {
71179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71180     return ;
71181   }
71182   arg2 = *argp2;
71183   {
71184     try {
71185       (arg1)->SetButtonImage(arg2);
71186     } catch (std::out_of_range& e) {
71187       {
71188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71189       };
71190     } catch (std::exception& e) {
71191       {
71192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71193       };
71194     } catch (Dali::DaliException e) {
71195       {
71196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71197       };
71198     } catch (...) {
71199       {
71200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71201       };
71202     }
71203   }
71204
71205 }
71206
71207
71208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71209   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71210   Dali::Actor arg2 ;
71211   Dali::Actor *argp2 ;
71212
71213   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71214   argp2 = (Dali::Actor *)jarg2;
71215   if (!argp2) {
71216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71217     return ;
71218   }
71219   arg2 = *argp2;
71220   {
71221     try {
71222       (arg1)->SetBackgroundImage(arg2);
71223     } catch (std::out_of_range& e) {
71224       {
71225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71226       };
71227     } catch (std::exception& e) {
71228       {
71229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71230       };
71231     } catch (Dali::DaliException e) {
71232       {
71233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71234       };
71235     } catch (...) {
71236       {
71237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71238       };
71239     }
71240   }
71241
71242 }
71243
71244
71245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71246   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71247   Dali::Image arg2 ;
71248   Dali::Image *argp2 ;
71249
71250   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71251   argp2 = (Dali::Image *)jarg2;
71252   if (!argp2) {
71253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71254     return ;
71255   }
71256   arg2 = *argp2;
71257   {
71258     try {
71259       (arg1)->SetSelectedImage(arg2);
71260     } catch (std::out_of_range& e) {
71261       {
71262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71263       };
71264     } catch (std::exception& e) {
71265       {
71266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71267       };
71268     } catch (Dali::DaliException e) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71271       };
71272     } catch (...) {
71273       {
71274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71275       };
71276     }
71277   }
71278
71279 }
71280
71281
71282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71283   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71284   Dali::Actor arg2 ;
71285   Dali::Actor *argp2 ;
71286
71287   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71288   argp2 = (Dali::Actor *)jarg2;
71289   if (!argp2) {
71290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71291     return ;
71292   }
71293   arg2 = *argp2;
71294   {
71295     try {
71296       (arg1)->SetSelectedImage(arg2);
71297     } catch (std::out_of_range& e) {
71298       {
71299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71300       };
71301     } catch (std::exception& e) {
71302       {
71303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71304       };
71305     } catch (Dali::DaliException e) {
71306       {
71307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71308       };
71309     } catch (...) {
71310       {
71311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71312       };
71313     }
71314   }
71315
71316 }
71317
71318
71319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71320   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71321   Dali::Actor arg2 ;
71322   Dali::Actor *argp2 ;
71323
71324   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71325   argp2 = (Dali::Actor *)jarg2;
71326   if (!argp2) {
71327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71328     return ;
71329   }
71330   arg2 = *argp2;
71331   {
71332     try {
71333       (arg1)->SetSelectedBackgroundImage(arg2);
71334     } catch (std::out_of_range& e) {
71335       {
71336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71337       };
71338     } catch (std::exception& e) {
71339       {
71340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71341       };
71342     } catch (Dali::DaliException e) {
71343       {
71344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71345       };
71346     } catch (...) {
71347       {
71348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71349       };
71350     }
71351   }
71352
71353 }
71354
71355
71356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71357   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71358   Dali::Actor arg2 ;
71359   Dali::Actor *argp2 ;
71360
71361   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71362   argp2 = (Dali::Actor *)jarg2;
71363   if (!argp2) {
71364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71365     return ;
71366   }
71367   arg2 = *argp2;
71368   {
71369     try {
71370       (arg1)->SetDisabledBackgroundImage(arg2);
71371     } catch (std::out_of_range& e) {
71372       {
71373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71374       };
71375     } catch (std::exception& e) {
71376       {
71377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71378       };
71379     } catch (Dali::DaliException e) {
71380       {
71381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71382       };
71383     } catch (...) {
71384       {
71385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71386       };
71387     }
71388   }
71389
71390 }
71391
71392
71393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71394   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71395   Dali::Actor arg2 ;
71396   Dali::Actor *argp2 ;
71397
71398   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71399   argp2 = (Dali::Actor *)jarg2;
71400   if (!argp2) {
71401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71402     return ;
71403   }
71404   arg2 = *argp2;
71405   {
71406     try {
71407       (arg1)->SetDisabledImage(arg2);
71408     } catch (std::out_of_range& e) {
71409       {
71410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71411       };
71412     } catch (std::exception& e) {
71413       {
71414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71415       };
71416     } catch (Dali::DaliException e) {
71417       {
71418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71419       };
71420     } catch (...) {
71421       {
71422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71423       };
71424     }
71425   }
71426
71427 }
71428
71429
71430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71431   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71432   Dali::Actor arg2 ;
71433   Dali::Actor *argp2 ;
71434
71435   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71436   argp2 = (Dali::Actor *)jarg2;
71437   if (!argp2) {
71438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71439     return ;
71440   }
71441   arg2 = *argp2;
71442   {
71443     try {
71444       (arg1)->SetDisabledSelectedImage(arg2);
71445     } catch (std::out_of_range& e) {
71446       {
71447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71448       };
71449     } catch (std::exception& e) {
71450       {
71451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71452       };
71453     } catch (Dali::DaliException e) {
71454       {
71455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71456       };
71457     } catch (...) {
71458       {
71459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71460       };
71461     }
71462   }
71463
71464 }
71465
71466
71467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71468   void * jresult ;
71469   Dali::Toolkit::RadioButton *result = 0 ;
71470
71471   {
71472     try {
71473       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71474     } catch (std::out_of_range& e) {
71475       {
71476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71477       };
71478     } catch (std::exception& e) {
71479       {
71480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71481       };
71482     } catch (Dali::DaliException e) {
71483       {
71484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71485       };
71486     } catch (...) {
71487       {
71488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71489       };
71490     }
71491   }
71492
71493   jresult = (void *)result;
71494   return jresult;
71495 }
71496
71497
71498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71499   void * jresult ;
71500   Dali::Toolkit::RadioButton *arg1 = 0 ;
71501   Dali::Toolkit::RadioButton *result = 0 ;
71502
71503   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71504   if (!arg1) {
71505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71506     return 0;
71507   }
71508   {
71509     try {
71510       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71511     } catch (std::out_of_range& e) {
71512       {
71513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71514       };
71515     } catch (std::exception& e) {
71516       {
71517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71518       };
71519     } catch (Dali::DaliException e) {
71520       {
71521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71522       };
71523     } catch (...) {
71524       {
71525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71526       };
71527     }
71528   }
71529
71530   jresult = (void *)result;
71531   return jresult;
71532 }
71533
71534
71535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71536   void * jresult ;
71537   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71538   Dali::Toolkit::RadioButton *arg2 = 0 ;
71539   Dali::Toolkit::RadioButton *result = 0 ;
71540
71541   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71542   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71543   if (!arg2) {
71544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71545     return 0;
71546   }
71547   {
71548     try {
71549       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71550     } catch (std::out_of_range& e) {
71551       {
71552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71553       };
71554     } catch (std::exception& e) {
71555       {
71556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71557       };
71558     } catch (Dali::DaliException e) {
71559       {
71560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71561       };
71562     } catch (...) {
71563       {
71564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71565       };
71566     }
71567   }
71568
71569   jresult = (void *)result;
71570   return jresult;
71571 }
71572
71573
71574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71575   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71576
71577   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71578   {
71579     try {
71580       delete arg1;
71581     } catch (std::out_of_range& e) {
71582       {
71583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71584       };
71585     } catch (std::exception& e) {
71586       {
71587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71588       };
71589     } catch (Dali::DaliException e) {
71590       {
71591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71592       };
71593     } catch (...) {
71594       {
71595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71596       };
71597     }
71598   }
71599
71600 }
71601
71602
71603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71604   void * jresult ;
71605   Dali::Toolkit::RadioButton result;
71606
71607   {
71608     try {
71609       result = Dali::Toolkit::RadioButton::New();
71610     } catch (std::out_of_range& e) {
71611       {
71612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71613       };
71614     } catch (std::exception& e) {
71615       {
71616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71617       };
71618     } catch (Dali::DaliException e) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71621       };
71622     } catch (...) {
71623       {
71624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71625       };
71626     }
71627   }
71628
71629   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71630   return jresult;
71631 }
71632
71633
71634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71635   void * jresult ;
71636   std::string *arg1 = 0 ;
71637   Dali::Toolkit::RadioButton result;
71638
71639   if (!jarg1) {
71640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71641     return 0;
71642   }
71643   std::string arg1_str(jarg1);
71644   arg1 = &arg1_str;
71645   {
71646     try {
71647       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71648     } catch (std::out_of_range& e) {
71649       {
71650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71651       };
71652     } catch (std::exception& e) {
71653       {
71654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71655       };
71656     } catch (Dali::DaliException e) {
71657       {
71658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71659       };
71660     } catch (...) {
71661       {
71662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71663       };
71664     }
71665   }
71666
71667   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71668
71669   //argout typemap for const std::string&
71670
71671   return jresult;
71672 }
71673
71674
71675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71676   void * jresult ;
71677   Dali::BaseHandle arg1 ;
71678   Dali::BaseHandle *argp1 ;
71679   Dali::Toolkit::RadioButton result;
71680
71681   argp1 = (Dali::BaseHandle *)jarg1;
71682   if (!argp1) {
71683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71684     return 0;
71685   }
71686   arg1 = *argp1;
71687   {
71688     try {
71689       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71690     } catch (std::out_of_range& e) {
71691       {
71692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71693       };
71694     } catch (std::exception& e) {
71695       {
71696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71697       };
71698     } catch (Dali::DaliException e) {
71699       {
71700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71701       };
71702     } catch (...) {
71703       {
71704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71705       };
71706     }
71707   }
71708
71709   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71710   return jresult;
71711 }
71712
71713
71714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71715   int jresult ;
71716   int result;
71717
71718   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71719   jresult = (int)result;
71720   return jresult;
71721 }
71722
71723
71724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71725   int jresult ;
71726   int result;
71727
71728   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71729   jresult = (int)result;
71730   return jresult;
71731 }
71732
71733
71734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71735   int jresult ;
71736   int result;
71737
71738   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71739   jresult = (int)result;
71740   return jresult;
71741 }
71742
71743
71744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71745   int jresult ;
71746   int result;
71747
71748   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71749   jresult = (int)result;
71750   return jresult;
71751 }
71752
71753
71754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71755   int jresult ;
71756   int result;
71757
71758   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71759   jresult = (int)result;
71760   return jresult;
71761 }
71762
71763
71764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71765   int jresult ;
71766   int result;
71767
71768   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71769   jresult = (int)result;
71770   return jresult;
71771 }
71772
71773
71774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71775   void * jresult ;
71776   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71777
71778   {
71779     try {
71780       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71781     } catch (std::out_of_range& e) {
71782       {
71783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71784       };
71785     } catch (std::exception& e) {
71786       {
71787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71788       };
71789     } catch (Dali::DaliException e) {
71790       {
71791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71792       };
71793     } catch (...) {
71794       {
71795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71796       };
71797     }
71798   }
71799
71800   jresult = (void *)result;
71801   return jresult;
71802 }
71803
71804
71805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71806   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71807
71808   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71809   {
71810     try {
71811       delete arg1;
71812     } catch (std::out_of_range& e) {
71813       {
71814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71815       };
71816     } catch (std::exception& e) {
71817       {
71818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71819       };
71820     } catch (Dali::DaliException e) {
71821       {
71822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71823       };
71824     } catch (...) {
71825       {
71826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71827       };
71828     }
71829   }
71830
71831 }
71832
71833
71834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71835   int jresult ;
71836   int result;
71837
71838   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71839   jresult = (int)result;
71840   return jresult;
71841 }
71842
71843
71844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71845   int jresult ;
71846   int result;
71847
71848   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71849   jresult = (int)result;
71850   return jresult;
71851 }
71852
71853
71854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71855   int jresult ;
71856   int result;
71857
71858   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71859   jresult = (int)result;
71860   return jresult;
71861 }
71862
71863
71864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71865   void * jresult ;
71866   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71867
71868   {
71869     try {
71870       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71871     } catch (std::out_of_range& e) {
71872       {
71873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71874       };
71875     } catch (std::exception& e) {
71876       {
71877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71878       };
71879     } catch (Dali::DaliException e) {
71880       {
71881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71882       };
71883     } catch (...) {
71884       {
71885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71886       };
71887     }
71888   }
71889
71890   jresult = (void *)result;
71891   return jresult;
71892 }
71893
71894
71895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71896   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71897
71898   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71899   {
71900     try {
71901       delete arg1;
71902     } catch (std::out_of_range& e) {
71903       {
71904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71905       };
71906     } catch (std::exception& e) {
71907       {
71908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71909       };
71910     } catch (Dali::DaliException e) {
71911       {
71912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71913       };
71914     } catch (...) {
71915       {
71916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71917       };
71918     }
71919   }
71920
71921 }
71922
71923
71924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71925   void * jresult ;
71926   Dali::Toolkit::FlexContainer *result = 0 ;
71927
71928   {
71929     try {
71930       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = (void *)result;
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71956   void * jresult ;
71957   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71958   Dali::Toolkit::FlexContainer *result = 0 ;
71959
71960   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71961   if (!arg1) {
71962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71963     return 0;
71964   }
71965   {
71966     try {
71967       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71968     } catch (std::out_of_range& e) {
71969       {
71970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71971       };
71972     } catch (std::exception& e) {
71973       {
71974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71975       };
71976     } catch (Dali::DaliException e) {
71977       {
71978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71979       };
71980     } catch (...) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71983       };
71984     }
71985   }
71986
71987   jresult = (void *)result;
71988   return jresult;
71989 }
71990
71991
71992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71993   void * jresult ;
71994   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71995   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71996   Dali::Toolkit::FlexContainer *result = 0 ;
71997
71998   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71999   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72000   if (!arg2) {
72001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72002     return 0;
72003   }
72004   {
72005     try {
72006       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72007     } catch (std::out_of_range& e) {
72008       {
72009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72010       };
72011     } catch (std::exception& e) {
72012       {
72013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72014       };
72015     } catch (Dali::DaliException e) {
72016       {
72017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72018       };
72019     } catch (...) {
72020       {
72021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72022       };
72023     }
72024   }
72025
72026   jresult = (void *)result;
72027   return jresult;
72028 }
72029
72030
72031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72032   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72033
72034   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72035   {
72036     try {
72037       delete arg1;
72038     } catch (std::out_of_range& e) {
72039       {
72040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72041       };
72042     } catch (std::exception& e) {
72043       {
72044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72045       };
72046     } catch (Dali::DaliException e) {
72047       {
72048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72049       };
72050     } catch (...) {
72051       {
72052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72053       };
72054     }
72055   }
72056
72057 }
72058
72059
72060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72061   void * jresult ;
72062   Dali::Toolkit::FlexContainer result;
72063
72064   {
72065     try {
72066       result = Dali::Toolkit::FlexContainer::New();
72067     } catch (std::out_of_range& e) {
72068       {
72069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72070       };
72071     } catch (std::exception& e) {
72072       {
72073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72074       };
72075     } catch (Dali::DaliException e) {
72076       {
72077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72078       };
72079     } catch (...) {
72080       {
72081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72082       };
72083     }
72084   }
72085
72086   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72087   return jresult;
72088 }
72089
72090
72091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72092   void * jresult ;
72093   Dali::BaseHandle arg1 ;
72094   Dali::BaseHandle *argp1 ;
72095   Dali::Toolkit::FlexContainer result;
72096
72097   argp1 = (Dali::BaseHandle *)jarg1;
72098   if (!argp1) {
72099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72100     return 0;
72101   }
72102   arg1 = *argp1;
72103   {
72104     try {
72105       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72106     } catch (std::out_of_range& e) {
72107       {
72108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (std::exception& e) {
72111       {
72112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72113       };
72114     } catch (Dali::DaliException e) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72117       };
72118     } catch (...) {
72119       {
72120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72121       };
72122     }
72123   }
72124
72125   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72126   return jresult;
72127 }
72128
72129
72130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72131   int jresult ;
72132   int result;
72133
72134   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72135   jresult = (int)result;
72136   return jresult;
72137 }
72138
72139
72140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72141   int jresult ;
72142   int result;
72143
72144   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72145   jresult = (int)result;
72146   return jresult;
72147 }
72148
72149
72150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72151   int jresult ;
72152   int result;
72153
72154   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72155   jresult = (int)result;
72156   return jresult;
72157 }
72158
72159
72160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72161   int jresult ;
72162   int result;
72163
72164   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72165   jresult = (int)result;
72166   return jresult;
72167 }
72168
72169
72170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72171   void * jresult ;
72172   Dali::Toolkit::ImageView::Property *result = 0 ;
72173
72174   {
72175     try {
72176       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72177     } catch (std::out_of_range& e) {
72178       {
72179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72180       };
72181     } catch (std::exception& e) {
72182       {
72183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72184       };
72185     } catch (Dali::DaliException e) {
72186       {
72187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72188       };
72189     } catch (...) {
72190       {
72191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72192       };
72193     }
72194   }
72195
72196   jresult = (void *)result;
72197   return jresult;
72198 }
72199
72200
72201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72202   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72203
72204   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72205   {
72206     try {
72207       delete arg1;
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72215       };
72216     } catch (Dali::DaliException e) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72219       };
72220     } catch (...) {
72221       {
72222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72223       };
72224     }
72225   }
72226
72227 }
72228
72229
72230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72231   void * jresult ;
72232   Dali::Toolkit::ImageView *result = 0 ;
72233
72234   {
72235     try {
72236       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72237     } catch (std::out_of_range& e) {
72238       {
72239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72240       };
72241     } catch (std::exception& e) {
72242       {
72243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72244       };
72245     } catch (Dali::DaliException e) {
72246       {
72247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72248       };
72249     } catch (...) {
72250       {
72251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72252       };
72253     }
72254   }
72255
72256   jresult = (void *)result;
72257   return jresult;
72258 }
72259
72260
72261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72262   void * jresult ;
72263   Dali::Toolkit::ImageView result;
72264
72265   {
72266     try {
72267       result = Dali::Toolkit::ImageView::New();
72268     } catch (std::out_of_range& e) {
72269       {
72270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72271       };
72272     } catch (std::exception& e) {
72273       {
72274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72275       };
72276     } catch (Dali::DaliException e) {
72277       {
72278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72279       };
72280     } catch (...) {
72281       {
72282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72283       };
72284     }
72285   }
72286
72287   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72288   return jresult;
72289 }
72290
72291
72292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72293   void * jresult ;
72294   Dali::Image arg1 ;
72295   Dali::Image *argp1 ;
72296   Dali::Toolkit::ImageView result;
72297
72298   argp1 = (Dali::Image *)jarg1;
72299   if (!argp1) {
72300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72301     return 0;
72302   }
72303   arg1 = *argp1;
72304   {
72305     try {
72306       result = Dali::Toolkit::ImageView::New(arg1);
72307     } catch (std::out_of_range& e) {
72308       {
72309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72310       };
72311     } catch (std::exception& e) {
72312       {
72313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72314       };
72315     } catch (Dali::DaliException e) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72318       };
72319     } catch (...) {
72320       {
72321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72322       };
72323     }
72324   }
72325
72326   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72327   return jresult;
72328 }
72329
72330
72331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72332   void * jresult ;
72333   std::string *arg1 = 0 ;
72334   Dali::Toolkit::ImageView result;
72335
72336   if (!jarg1) {
72337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72338     return 0;
72339   }
72340   std::string arg1_str(jarg1);
72341   arg1 = &arg1_str;
72342   {
72343     try {
72344       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72345     } catch (std::out_of_range& e) {
72346       {
72347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72348       };
72349     } catch (std::exception& e) {
72350       {
72351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72352       };
72353     } catch (Dali::DaliException e) {
72354       {
72355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72356       };
72357     } catch (...) {
72358       {
72359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72360       };
72361     }
72362   }
72363
72364   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72365
72366   //argout typemap for const std::string&
72367
72368   return jresult;
72369 }
72370
72371
72372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72373   void * jresult ;
72374   std::string *arg1 = 0 ;
72375   Dali::ImageDimensions arg2 ;
72376   Dali::ImageDimensions *argp2 ;
72377   Dali::Toolkit::ImageView result;
72378
72379   if (!jarg1) {
72380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72381     return 0;
72382   }
72383   std::string arg1_str(jarg1);
72384   arg1 = &arg1_str;
72385   argp2 = (Dali::ImageDimensions *)jarg2;
72386   if (!argp2) {
72387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72388     return 0;
72389   }
72390   arg2 = *argp2;
72391   {
72392     try {
72393       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72394     } catch (std::out_of_range& e) {
72395       {
72396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72397       };
72398     } catch (std::exception& e) {
72399       {
72400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72401       };
72402     } catch (Dali::DaliException e) {
72403       {
72404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72405       };
72406     } catch (...) {
72407       {
72408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72409       };
72410     }
72411   }
72412
72413   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72414
72415   //argout typemap for const std::string&
72416
72417   return jresult;
72418 }
72419
72420
72421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72422   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72423
72424   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72425   {
72426     try {
72427       delete arg1;
72428     } catch (std::out_of_range& e) {
72429       {
72430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72431       };
72432     } catch (std::exception& e) {
72433       {
72434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72435       };
72436     } catch (Dali::DaliException e) {
72437       {
72438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72439       };
72440     } catch (...) {
72441       {
72442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72443       };
72444     }
72445   }
72446
72447 }
72448
72449
72450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72451   void * jresult ;
72452   Dali::Toolkit::ImageView *arg1 = 0 ;
72453   Dali::Toolkit::ImageView *result = 0 ;
72454
72455   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72456   if (!arg1) {
72457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72458     return 0;
72459   }
72460   {
72461     try {
72462       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72463     } catch (std::out_of_range& e) {
72464       {
72465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (std::exception& e) {
72468       {
72469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72470       };
72471     } catch (Dali::DaliException e) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72474       };
72475     } catch (...) {
72476       {
72477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72478       };
72479     }
72480   }
72481
72482   jresult = (void *)result;
72483   return jresult;
72484 }
72485
72486
72487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72488   void * jresult ;
72489   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72490   Dali::Toolkit::ImageView *arg2 = 0 ;
72491   Dali::Toolkit::ImageView *result = 0 ;
72492
72493   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72494   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72495   if (!arg2) {
72496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72497     return 0;
72498   }
72499   {
72500     try {
72501       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72502     } catch (std::out_of_range& e) {
72503       {
72504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72505       };
72506     } catch (std::exception& e) {
72507       {
72508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72509       };
72510     } catch (Dali::DaliException e) {
72511       {
72512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72513       };
72514     } catch (...) {
72515       {
72516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72517       };
72518     }
72519   }
72520
72521   jresult = (void *)result;
72522   return jresult;
72523 }
72524
72525
72526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72527   void * jresult ;
72528   Dali::BaseHandle arg1 ;
72529   Dali::BaseHandle *argp1 ;
72530   Dali::Toolkit::ImageView result;
72531
72532   argp1 = (Dali::BaseHandle *)jarg1;
72533   if (!argp1) {
72534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72535     return 0;
72536   }
72537   arg1 = *argp1;
72538   {
72539     try {
72540       result = Dali::Toolkit::ImageView::DownCast(arg1);
72541     } catch (std::out_of_range& e) {
72542       {
72543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (std::exception& e) {
72546       {
72547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72548       };
72549     } catch (Dali::DaliException e) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72552       };
72553     } catch (...) {
72554       {
72555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72556       };
72557     }
72558   }
72559
72560   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72561   return jresult;
72562 }
72563
72564
72565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72566   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72567   Dali::Image arg2 ;
72568   Dali::Image *argp2 ;
72569
72570   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72571   argp2 = (Dali::Image *)jarg2;
72572   if (!argp2) {
72573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72574     return ;
72575   }
72576   arg2 = *argp2;
72577   {
72578     try {
72579       (arg1)->SetImage(arg2);
72580     } catch (std::out_of_range& e) {
72581       {
72582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72583       };
72584     } catch (std::exception& e) {
72585       {
72586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72587       };
72588     } catch (Dali::DaliException e) {
72589       {
72590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72591       };
72592     } catch (...) {
72593       {
72594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72595       };
72596     }
72597   }
72598
72599 }
72600
72601
72602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72603   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72604   std::string *arg2 = 0 ;
72605
72606   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72607   if (!jarg2) {
72608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72609     return ;
72610   }
72611   std::string arg2_str(jarg2);
72612   arg2 = &arg2_str;
72613   {
72614     try {
72615       (arg1)->SetImage((std::string const &)*arg2);
72616     } catch (std::out_of_range& e) {
72617       {
72618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72619       };
72620     } catch (std::exception& e) {
72621       {
72622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72623       };
72624     } catch (Dali::DaliException e) {
72625       {
72626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72627       };
72628     } catch (...) {
72629       {
72630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72631       };
72632     }
72633   }
72634
72635
72636   //argout typemap for const std::string&
72637
72638 }
72639
72640
72641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72642   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72643   std::string *arg2 = 0 ;
72644   Dali::ImageDimensions arg3 ;
72645   Dali::ImageDimensions *argp3 ;
72646
72647   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72648   if (!jarg2) {
72649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72650     return ;
72651   }
72652   std::string arg2_str(jarg2);
72653   arg2 = &arg2_str;
72654   argp3 = (Dali::ImageDimensions *)jarg3;
72655   if (!argp3) {
72656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72657     return ;
72658   }
72659   arg3 = *argp3;
72660   {
72661     try {
72662       (arg1)->SetImage((std::string const &)*arg2,arg3);
72663     } catch (std::out_of_range& e) {
72664       {
72665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72666       };
72667     } catch (std::exception& e) {
72668       {
72669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72670       };
72671     } catch (Dali::DaliException e) {
72672       {
72673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72674       };
72675     } catch (...) {
72676       {
72677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72678       };
72679     }
72680   }
72681
72682
72683   //argout typemap for const std::string&
72684
72685 }
72686
72687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72688   void * jresult ;
72689   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72690   Dali::Image result;
72691
72692   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72693   {
72694     try {
72695       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72696     } catch (std::out_of_range& e) {
72697       {
72698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72699       };
72700     } catch (std::exception& e) {
72701       {
72702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72703       };
72704     } catch (Dali::DaliException e) {
72705       {
72706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72707       };
72708     } catch (...) {
72709       {
72710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72711       };
72712     }
72713   }
72714
72715   jresult = new Dali::Image((const Dali::Image &)result);
72716   return jresult;
72717 }
72718
72719
72720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72721   int jresult ;
72722   int result;
72723
72724   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72725   jresult = (int)result;
72726   return jresult;
72727 }
72728
72729
72730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72731   int jresult ;
72732   int result;
72733
72734   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72735   jresult = (int)result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72741   int jresult ;
72742   int result;
72743
72744   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72745   jresult = (int)result;
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72751   int jresult ;
72752   int result;
72753
72754   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72755   jresult = (int)result;
72756   return jresult;
72757 }
72758
72759
72760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72761   int jresult ;
72762   int result;
72763
72764   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72765   jresult = (int)result;
72766   return jresult;
72767 }
72768
72769
72770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72771   int jresult ;
72772   int result;
72773
72774   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72775   jresult = (int)result;
72776   return jresult;
72777 }
72778
72779
72780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72781   int jresult ;
72782   int result;
72783
72784   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72785   jresult = (int)result;
72786   return jresult;
72787 }
72788
72789
72790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72791   int jresult ;
72792   int result;
72793
72794   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72795   jresult = (int)result;
72796   return jresult;
72797 }
72798
72799
72800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72801   void * jresult ;
72802   Dali::Toolkit::Model3dView::Property *result = 0 ;
72803
72804   {
72805     try {
72806       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72807     } catch (std::out_of_range& e) {
72808       {
72809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72810       };
72811     } catch (std::exception& e) {
72812       {
72813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72814       };
72815     } catch (Dali::DaliException e) {
72816       {
72817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72818       };
72819     } catch (...) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72822       };
72823     }
72824   }
72825
72826   jresult = (void *)result;
72827   return jresult;
72828 }
72829
72830
72831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72832   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72833
72834   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72835   {
72836     try {
72837       delete arg1;
72838     } catch (std::out_of_range& e) {
72839       {
72840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72841       };
72842     } catch (std::exception& e) {
72843       {
72844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72845       };
72846     } catch (Dali::DaliException e) {
72847       {
72848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72849       };
72850     } catch (...) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72853       };
72854     }
72855   }
72856
72857 }
72858
72859
72860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72861   void * jresult ;
72862   Dali::Toolkit::Model3dView result;
72863
72864   {
72865     try {
72866       result = Dali::Toolkit::Model3dView::New();
72867     } catch (std::out_of_range& e) {
72868       {
72869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72870       };
72871     } catch (std::exception& e) {
72872       {
72873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72874       };
72875     } catch (Dali::DaliException e) {
72876       {
72877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72878       };
72879     } catch (...) {
72880       {
72881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72882       };
72883     }
72884   }
72885
72886   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72887   return jresult;
72888 }
72889
72890
72891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72892   void * jresult ;
72893   std::string *arg1 = 0 ;
72894   std::string *arg2 = 0 ;
72895   std::string *arg3 = 0 ;
72896   Dali::Toolkit::Model3dView result;
72897
72898   if (!jarg1) {
72899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72900     return 0;
72901   }
72902   std::string arg1_str(jarg1);
72903   arg1 = &arg1_str;
72904   if (!jarg2) {
72905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72906     return 0;
72907   }
72908   std::string arg2_str(jarg2);
72909   arg2 = &arg2_str;
72910   if (!jarg3) {
72911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72912     return 0;
72913   }
72914   std::string arg3_str(jarg3);
72915   arg3 = &arg3_str;
72916   {
72917     try {
72918       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72919     } catch (std::out_of_range& e) {
72920       {
72921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (std::exception& e) {
72924       {
72925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72926       };
72927     } catch (Dali::DaliException e) {
72928       {
72929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72930       };
72931     } catch (...) {
72932       {
72933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72934       };
72935     }
72936   }
72937
72938   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72939
72940   //argout typemap for const std::string&
72941
72942
72943   //argout typemap for const std::string&
72944
72945
72946   //argout typemap for const std::string&
72947
72948   return jresult;
72949 }
72950
72951
72952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72953   void * jresult ;
72954   Dali::Toolkit::Model3dView *result = 0 ;
72955
72956   {
72957     try {
72958       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72959     } catch (std::out_of_range& e) {
72960       {
72961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72962       };
72963     } catch (std::exception& e) {
72964       {
72965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72966       };
72967     } catch (Dali::DaliException e) {
72968       {
72969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72970       };
72971     } catch (...) {
72972       {
72973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72974       };
72975     }
72976   }
72977
72978   jresult = (void *)result;
72979   return jresult;
72980 }
72981
72982
72983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72984   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72985
72986   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72987   {
72988     try {
72989       delete arg1;
72990     } catch (std::out_of_range& e) {
72991       {
72992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72993       };
72994     } catch (std::exception& e) {
72995       {
72996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72997       };
72998     } catch (Dali::DaliException e) {
72999       {
73000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73001       };
73002     } catch (...) {
73003       {
73004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73005       };
73006     }
73007   }
73008
73009 }
73010
73011
73012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73013   void * jresult ;
73014   Dali::Toolkit::Model3dView *arg1 = 0 ;
73015   Dali::Toolkit::Model3dView *result = 0 ;
73016
73017   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73018   if (!arg1) {
73019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73020     return 0;
73021   }
73022   {
73023     try {
73024       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73025     } catch (std::out_of_range& e) {
73026       {
73027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73028       };
73029     } catch (std::exception& e) {
73030       {
73031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73032       };
73033     } catch (Dali::DaliException e) {
73034       {
73035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73036       };
73037     } catch (...) {
73038       {
73039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73040       };
73041     }
73042   }
73043
73044   jresult = (void *)result;
73045   return jresult;
73046 }
73047
73048
73049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73050   void * jresult ;
73051   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73052   Dali::Toolkit::Model3dView *arg2 = 0 ;
73053   Dali::Toolkit::Model3dView *result = 0 ;
73054
73055   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73056   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73057   if (!arg2) {
73058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73059     return 0;
73060   }
73061   {
73062     try {
73063       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73064     } catch (std::out_of_range& e) {
73065       {
73066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73067       };
73068     } catch (std::exception& e) {
73069       {
73070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73071       };
73072     } catch (Dali::DaliException e) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73075       };
73076     } catch (...) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73079       };
73080     }
73081   }
73082
73083   jresult = (void *)result;
73084   return jresult;
73085 }
73086
73087
73088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73089   void * jresult ;
73090   Dali::BaseHandle arg1 ;
73091   Dali::BaseHandle *argp1 ;
73092   Dali::Toolkit::Model3dView result;
73093
73094   argp1 = (Dali::BaseHandle *)jarg1;
73095   if (!argp1) {
73096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73097     return 0;
73098   }
73099   arg1 = *argp1;
73100   {
73101     try {
73102       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73103     } catch (std::out_of_range& e) {
73104       {
73105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73106       };
73107     } catch (std::exception& e) {
73108       {
73109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73110       };
73111     } catch (Dali::DaliException e) {
73112       {
73113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73114       };
73115     } catch (...) {
73116       {
73117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73118       };
73119     }
73120   }
73121
73122   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73123   return jresult;
73124 }
73125
73126
73127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73128   int jresult ;
73129   int result;
73130
73131   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73132   jresult = (int)result;
73133   return jresult;
73134 }
73135
73136
73137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73138   int jresult ;
73139   int result;
73140
73141   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73142   jresult = (int)result;
73143   return jresult;
73144 }
73145
73146
73147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73148   int jresult ;
73149   int result;
73150
73151   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73152   jresult = (int)result;
73153   return jresult;
73154 }
73155
73156
73157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73158   int jresult ;
73159   int result;
73160
73161   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73162   jresult = (int)result;
73163   return jresult;
73164 }
73165
73166
73167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73168   int jresult ;
73169   int result;
73170
73171   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73172   jresult = (int)result;
73173   return jresult;
73174 }
73175
73176
73177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73178   int jresult ;
73179   int result;
73180
73181   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73182   jresult = (int)result;
73183   return jresult;
73184 }
73185
73186
73187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73188   int jresult ;
73189   int result;
73190
73191   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73192   jresult = (int)result;
73193   return jresult;
73194 }
73195
73196
73197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73198   int jresult ;
73199   int result;
73200
73201   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73202   jresult = (int)result;
73203   return jresult;
73204 }
73205
73206
73207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73208   int jresult ;
73209   int result;
73210
73211   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73212   jresult = (int)result;
73213   return jresult;
73214 }
73215
73216
73217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73218   void * jresult ;
73219   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73220
73221   {
73222     try {
73223       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73224     } catch (std::out_of_range& e) {
73225       {
73226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73227       };
73228     } catch (std::exception& e) {
73229       {
73230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73231       };
73232     } catch (Dali::DaliException e) {
73233       {
73234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73235       };
73236     } catch (...) {
73237       {
73238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73239       };
73240     }
73241   }
73242
73243   jresult = (void *)result;
73244   return jresult;
73245 }
73246
73247
73248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73249   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73250
73251   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73252   {
73253     try {
73254       delete arg1;
73255     } catch (std::out_of_range& e) {
73256       {
73257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73258       };
73259     } catch (std::exception& e) {
73260       {
73261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73262       };
73263     } catch (Dali::DaliException e) {
73264       {
73265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73266       };
73267     } catch (...) {
73268       {
73269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73270       };
73271     }
73272   }
73273
73274 }
73275
73276
73277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73278   void * jresult ;
73279   Dali::Toolkit::ScrollBar *result = 0 ;
73280
73281   {
73282     try {
73283       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (Dali::DaliException e) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73295       };
73296     } catch (...) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73299       };
73300     }
73301   }
73302
73303   jresult = (void *)result;
73304   return jresult;
73305 }
73306
73307
73308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73309   void * jresult ;
73310   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73311   Dali::Toolkit::ScrollBar *result = 0 ;
73312
73313   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73314   if (!arg1) {
73315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73316     return 0;
73317   }
73318   {
73319     try {
73320       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73321     } catch (std::out_of_range& e) {
73322       {
73323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (std::exception& e) {
73326       {
73327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73328       };
73329     } catch (Dali::DaliException e) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73332       };
73333     } catch (...) {
73334       {
73335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73336       };
73337     }
73338   }
73339
73340   jresult = (void *)result;
73341   return jresult;
73342 }
73343
73344
73345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73346   void * jresult ;
73347   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73348   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73349   Dali::Toolkit::ScrollBar *result = 0 ;
73350
73351   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73352   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73353   if (!arg2) {
73354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73355     return 0;
73356   }
73357   {
73358     try {
73359       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73360     } catch (std::out_of_range& e) {
73361       {
73362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (std::exception& e) {
73365       {
73366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73367       };
73368     } catch (Dali::DaliException e) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73371       };
73372     } catch (...) {
73373       {
73374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73375       };
73376     }
73377   }
73378
73379   jresult = (void *)result;
73380   return jresult;
73381 }
73382
73383
73384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73385   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73386
73387   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73388   {
73389     try {
73390       delete arg1;
73391     } catch (std::out_of_range& e) {
73392       {
73393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73394       };
73395     } catch (std::exception& e) {
73396       {
73397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73398       };
73399     } catch (Dali::DaliException e) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73402       };
73403     } catch (...) {
73404       {
73405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73406       };
73407     }
73408   }
73409
73410 }
73411
73412
73413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73414   void * jresult ;
73415   Dali::Toolkit::ScrollBar::Direction arg1 ;
73416   Dali::Toolkit::ScrollBar result;
73417
73418   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73419   {
73420     try {
73421       result = Dali::Toolkit::ScrollBar::New(arg1);
73422     } catch (std::out_of_range& e) {
73423       {
73424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (std::exception& e) {
73427       {
73428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (Dali::DaliException e) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440
73441   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73442   return jresult;
73443 }
73444
73445
73446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73447   void * jresult ;
73448   Dali::Toolkit::ScrollBar result;
73449
73450   {
73451     try {
73452       result = Dali::Toolkit::ScrollBar::New();
73453     } catch (std::out_of_range& e) {
73454       {
73455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73456       };
73457     } catch (std::exception& e) {
73458       {
73459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73460       };
73461     } catch (Dali::DaliException e) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73464       };
73465     } catch (...) {
73466       {
73467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73468       };
73469     }
73470   }
73471
73472   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73473   return jresult;
73474 }
73475
73476
73477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73478   void * jresult ;
73479   Dali::BaseHandle arg1 ;
73480   Dali::BaseHandle *argp1 ;
73481   Dali::Toolkit::ScrollBar result;
73482
73483   argp1 = (Dali::BaseHandle *)jarg1;
73484   if (!argp1) {
73485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73486     return 0;
73487   }
73488   arg1 = *argp1;
73489   {
73490     try {
73491       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73492     } catch (std::out_of_range& e) {
73493       {
73494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73495       };
73496     } catch (std::exception& e) {
73497       {
73498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73499       };
73500     } catch (Dali::DaliException e) {
73501       {
73502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73503       };
73504     } catch (...) {
73505       {
73506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73507       };
73508     }
73509   }
73510
73511   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73512   return jresult;
73513 }
73514
73515
73516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73517   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73518   Dali::Handle arg2 ;
73519   Dali::Property::Index arg3 ;
73520   Dali::Property::Index arg4 ;
73521   Dali::Property::Index arg5 ;
73522   Dali::Property::Index arg6 ;
73523   Dali::Handle *argp2 ;
73524
73525   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73526   argp2 = (Dali::Handle *)jarg2;
73527   if (!argp2) {
73528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73529     return ;
73530   }
73531   arg2 = *argp2;
73532   arg3 = (Dali::Property::Index)jarg3;
73533   arg4 = (Dali::Property::Index)jarg4;
73534   arg5 = (Dali::Property::Index)jarg5;
73535   arg6 = (Dali::Property::Index)jarg6;
73536   {
73537     try {
73538       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73539     } catch (std::out_of_range& e) {
73540       {
73541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73542       };
73543     } catch (std::exception& e) {
73544       {
73545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73546       };
73547     } catch (Dali::DaliException e) {
73548       {
73549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73550       };
73551     } catch (...) {
73552       {
73553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73554       };
73555     }
73556   }
73557
73558 }
73559
73560
73561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73562   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73563   Dali::Actor arg2 ;
73564   Dali::Actor *argp2 ;
73565
73566   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73567   argp2 = (Dali::Actor *)jarg2;
73568   if (!argp2) {
73569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73570     return ;
73571   }
73572   arg2 = *argp2;
73573   {
73574     try {
73575       (arg1)->SetScrollIndicator(arg2);
73576     } catch (std::out_of_range& e) {
73577       {
73578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73579       };
73580     } catch (std::exception& e) {
73581       {
73582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73583       };
73584     } catch (Dali::DaliException e) {
73585       {
73586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73587       };
73588     } catch (...) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73591       };
73592     }
73593   }
73594
73595 }
73596
73597
73598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73599   void * jresult ;
73600   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73601   Dali::Actor result;
73602
73603   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73604   {
73605     try {
73606       result = (arg1)->GetScrollIndicator();
73607     } catch (std::out_of_range& e) {
73608       {
73609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73610       };
73611     } catch (std::exception& e) {
73612       {
73613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73614       };
73615     } catch (Dali::DaliException e) {
73616       {
73617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73618       };
73619     } catch (...) {
73620       {
73621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73622       };
73623     }
73624   }
73625
73626   jresult = new Dali::Actor((const Dali::Actor &)result);
73627   return jresult;
73628 }
73629
73630
73631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73632   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73633   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73634
73635   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73636   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73637   if (!arg2) {
73638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73639     return ;
73640   }
73641   {
73642     try {
73643       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73644     } catch (std::out_of_range& e) {
73645       {
73646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73647       };
73648     } catch (std::exception& e) {
73649       {
73650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73651       };
73652     } catch (Dali::DaliException e) {
73653       {
73654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73655       };
73656     } catch (...) {
73657       {
73658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73659       };
73660     }
73661   }
73662
73663 }
73664
73665
73666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73667   void * jresult ;
73668   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73669
73670   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73671   {
73672     try {
73673       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()));
73674     } catch (std::out_of_range& e) {
73675       {
73676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73677       };
73678     } catch (std::exception& e) {
73679       {
73680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73681       };
73682     } catch (...) {
73683       {
73684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73685       };
73686     }
73687   }
73688   return jresult;
73689 }
73690
73691
73692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73693   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73694   Dali::Toolkit::ScrollBar::Direction arg2 ;
73695
73696   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73697   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73698   {
73699     try {
73700       (arg1)->SetScrollDirection(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_GetScrollDirection(void * jarg1) {
73724   int jresult ;
73725   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73726   Dali::Toolkit::ScrollBar::Direction result;
73727
73728   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73729   {
73730     try {
73731       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
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_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73757   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73758   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73759
73760   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73761   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73762   {
73763     try {
73764       (arg1)->SetIndicatorHeightPolicy(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 int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73788   int jresult ;
73789   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73790   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73791
73792   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73793   {
73794     try {
73795       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
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 = (int)result;
73816   return jresult;
73817 }
73818
73819
73820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(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)->SetIndicatorFixedHeight(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_GetIndicatorFixedHeight(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)->GetIndicatorFixedHeight();
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_SetIndicatorShowDuration(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)->SetIndicatorShowDuration(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_GetIndicatorShowDuration(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)->GetIndicatorShowDuration();
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_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73949   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73950   float arg2 ;
73951
73952   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73953   arg2 = (float)jarg2;
73954   {
73955     try {
73956       (arg1)->SetIndicatorHideDuration(arg2);
73957     } catch (std::out_of_range& e) {
73958       {
73959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73960       };
73961     } catch (std::exception& e) {
73962       {
73963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73964       };
73965     } catch (Dali::DaliException e) {
73966       {
73967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73968       };
73969     } catch (...) {
73970       {
73971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73972       };
73973     }
73974   }
73975
73976 }
73977
73978
73979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73980   float jresult ;
73981   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73982   float result;
73983
73984   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73985   {
73986     try {
73987       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73988     } catch (std::out_of_range& e) {
73989       {
73990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (std::exception& e) {
73993       {
73994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73995       };
73996     } catch (Dali::DaliException e) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73999       };
74000     } catch (...) {
74001       {
74002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74003       };
74004     }
74005   }
74006
74007   jresult = result;
74008   return jresult;
74009 }
74010
74011
74012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74013   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74014
74015   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74016   {
74017     try {
74018       (arg1)->ShowIndicator();
74019     } catch (std::out_of_range& e) {
74020       {
74021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74022       };
74023     } catch (std::exception& e) {
74024       {
74025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74026       };
74027     } catch (Dali::DaliException e) {
74028       {
74029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74030       };
74031     } catch (...) {
74032       {
74033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74034       };
74035     }
74036   }
74037
74038 }
74039
74040
74041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74042   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74043
74044   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74045   {
74046     try {
74047       (arg1)->HideIndicator();
74048     } catch (std::out_of_range& e) {
74049       {
74050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74051       };
74052     } catch (std::exception& e) {
74053       {
74054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74055       };
74056     } catch (Dali::DaliException e) {
74057       {
74058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74059       };
74060     } catch (...) {
74061       {
74062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74063       };
74064     }
74065   }
74066
74067 }
74068
74069
74070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74071   void * jresult ;
74072   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74073   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74074
74075   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74076   {
74077     try {
74078       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74079     } catch (std::out_of_range& e) {
74080       {
74081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74082       };
74083     } catch (std::exception& e) {
74084       {
74085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (Dali::DaliException e) {
74088       {
74089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74090       };
74091     } catch (...) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74094       };
74095     }
74096   }
74097
74098   jresult = (void *)result;
74099   return jresult;
74100 }
74101
74102
74103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74104   void * jresult ;
74105   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74106   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74107
74108   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74109   {
74110     try {
74111       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74112     } catch (std::out_of_range& e) {
74113       {
74114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74115       };
74116     } catch (std::exception& e) {
74117       {
74118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74119       };
74120     } catch (Dali::DaliException e) {
74121       {
74122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74123       };
74124     } catch (...) {
74125       {
74126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74127       };
74128     }
74129   }
74130
74131   jresult = (void *)result;
74132   return jresult;
74133 }
74134
74135
74136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74137   int jresult ;
74138   int result;
74139
74140   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74141   jresult = (int)result;
74142   return jresult;
74143 }
74144
74145
74146 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74147   int jresult ;
74148   int result;
74149
74150   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74151   jresult = (int)result;
74152   return jresult;
74153 }
74154
74155
74156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74157   int jresult ;
74158   int result;
74159
74160   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74161   jresult = (int)result;
74162   return jresult;
74163 }
74164
74165
74166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74167   int jresult ;
74168   int result;
74169
74170   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74171   jresult = (int)result;
74172   return jresult;
74173 }
74174
74175
74176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74177   int jresult ;
74178   int result;
74179
74180   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74181   jresult = (int)result;
74182   return jresult;
74183 }
74184
74185
74186 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74187   int jresult ;
74188   int result;
74189
74190   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74191   jresult = (int)result;
74192   return jresult;
74193 }
74194
74195
74196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74197   int jresult ;
74198   int result;
74199
74200   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74201   jresult = (int)result;
74202   return jresult;
74203 }
74204
74205
74206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74207   int jresult ;
74208   int result;
74209
74210   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74211   jresult = (int)result;
74212   return jresult;
74213 }
74214
74215
74216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74217   int jresult ;
74218   int result;
74219
74220   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74221   jresult = (int)result;
74222   return jresult;
74223 }
74224
74225
74226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74227   int jresult ;
74228   int result;
74229
74230   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74231   jresult = (int)result;
74232   return jresult;
74233 }
74234
74235
74236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74237   int jresult ;
74238   int result;
74239
74240   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74241   jresult = (int)result;
74242   return jresult;
74243 }
74244
74245
74246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74247   int jresult ;
74248   int result;
74249
74250   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74251   jresult = (int)result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74257   int jresult ;
74258   int result;
74259
74260   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74261   jresult = (int)result;
74262   return jresult;
74263 }
74264
74265
74266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74267   int jresult ;
74268   int result;
74269
74270   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74271   jresult = (int)result;
74272   return jresult;
74273 }
74274
74275
74276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74277   void * jresult ;
74278   Dali::Toolkit::Scrollable::Property *result = 0 ;
74279
74280   {
74281     try {
74282       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74283     } catch (std::out_of_range& e) {
74284       {
74285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74286       };
74287     } catch (std::exception& e) {
74288       {
74289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74290       };
74291     } catch (Dali::DaliException e) {
74292       {
74293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74294       };
74295     } catch (...) {
74296       {
74297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74298       };
74299     }
74300   }
74301
74302   jresult = (void *)result;
74303   return jresult;
74304 }
74305
74306
74307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74308   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74309
74310   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74311   {
74312     try {
74313       delete arg1;
74314     } catch (std::out_of_range& e) {
74315       {
74316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74317       };
74318     } catch (std::exception& e) {
74319       {
74320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74321       };
74322     } catch (Dali::DaliException e) {
74323       {
74324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74325       };
74326     } catch (...) {
74327       {
74328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74329       };
74330     }
74331   }
74332
74333 }
74334
74335
74336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74337   void * jresult ;
74338   Dali::Toolkit::Scrollable *result = 0 ;
74339
74340   {
74341     try {
74342       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74343     } catch (std::out_of_range& e) {
74344       {
74345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74346       };
74347     } catch (std::exception& e) {
74348       {
74349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74350       };
74351     } catch (Dali::DaliException e) {
74352       {
74353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74354       };
74355     } catch (...) {
74356       {
74357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74358       };
74359     }
74360   }
74361
74362   jresult = (void *)result;
74363   return jresult;
74364 }
74365
74366
74367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74368   void * jresult ;
74369   Dali::Toolkit::Scrollable *arg1 = 0 ;
74370   Dali::Toolkit::Scrollable *result = 0 ;
74371
74372   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74373   if (!arg1) {
74374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74375     return 0;
74376   }
74377   {
74378     try {
74379       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74380     } catch (std::out_of_range& e) {
74381       {
74382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74383       };
74384     } catch (std::exception& e) {
74385       {
74386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74387       };
74388     } catch (Dali::DaliException e) {
74389       {
74390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74391       };
74392     } catch (...) {
74393       {
74394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74395       };
74396     }
74397   }
74398
74399   jresult = (void *)result;
74400   return jresult;
74401 }
74402
74403
74404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74405   void * jresult ;
74406   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74407   Dali::Toolkit::Scrollable *arg2 = 0 ;
74408   Dali::Toolkit::Scrollable *result = 0 ;
74409
74410   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74411   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74412   if (!arg2) {
74413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74414     return 0;
74415   }
74416   {
74417     try {
74418       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74419     } catch (std::out_of_range& e) {
74420       {
74421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74422       };
74423     } catch (std::exception& e) {
74424       {
74425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74426       };
74427     } catch (Dali::DaliException e) {
74428       {
74429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74430       };
74431     } catch (...) {
74432       {
74433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74434       };
74435     }
74436   }
74437
74438   jresult = (void *)result;
74439   return jresult;
74440 }
74441
74442
74443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74444   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74445
74446   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74447   {
74448     try {
74449       delete arg1;
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74457       };
74458     } catch (Dali::DaliException e) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74461       };
74462     } catch (...) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74465       };
74466     }
74467   }
74468
74469 }
74470
74471
74472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74473   void * jresult ;
74474   Dali::BaseHandle arg1 ;
74475   Dali::BaseHandle *argp1 ;
74476   Dali::Toolkit::Scrollable result;
74477
74478   argp1 = (Dali::BaseHandle *)jarg1;
74479   if (!argp1) {
74480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74481     return 0;
74482   }
74483   arg1 = *argp1;
74484   {
74485     try {
74486       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74487     } catch (std::out_of_range& e) {
74488       {
74489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (std::exception& e) {
74492       {
74493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74494       };
74495     } catch (Dali::DaliException e) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74498       };
74499     } catch (...) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74502       };
74503     }
74504   }
74505
74506   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74507   return jresult;
74508 }
74509
74510
74511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74512   unsigned int jresult ;
74513   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74514   bool result;
74515
74516   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74517   {
74518     try {
74519       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74520     } catch (std::out_of_range& e) {
74521       {
74522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74523       };
74524     } catch (std::exception& e) {
74525       {
74526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74527       };
74528     } catch (Dali::DaliException e) {
74529       {
74530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74531       };
74532     } catch (...) {
74533       {
74534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74535       };
74536     }
74537   }
74538
74539   jresult = result;
74540   return jresult;
74541 }
74542
74543
74544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74545   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74546   bool arg2 ;
74547
74548   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74549   arg2 = jarg2 ? true : false;
74550   {
74551     try {
74552       (arg1)->SetOvershootEnabled(arg2);
74553     } catch (std::out_of_range& e) {
74554       {
74555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74556       };
74557     } catch (std::exception& e) {
74558       {
74559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74560       };
74561     } catch (Dali::DaliException e) {
74562       {
74563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74564       };
74565     } catch (...) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74568       };
74569     }
74570   }
74571
74572 }
74573
74574
74575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74576   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74577   Dali::Vector4 *arg2 = 0 ;
74578
74579   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74580   arg2 = (Dali::Vector4 *)jarg2;
74581   if (!arg2) {
74582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74583     return ;
74584   }
74585   {
74586     try {
74587       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*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 void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74611   void * jresult ;
74612   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74613   Dali::Vector4 result;
74614
74615   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74616   {
74617     try {
74618       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
74639   return jresult;
74640 }
74641
74642
74643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74644   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74645   float arg2 ;
74646
74647   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74648   arg2 = (float)jarg2;
74649   {
74650     try {
74651       (arg1)->SetOvershootAnimationSpeed(arg2);
74652     } catch (std::out_of_range& e) {
74653       {
74654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74655       };
74656     } catch (std::exception& e) {
74657       {
74658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74659       };
74660     } catch (Dali::DaliException e) {
74661       {
74662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74663       };
74664     } catch (...) {
74665       {
74666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74667       };
74668     }
74669   }
74670
74671 }
74672
74673
74674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74675   float jresult ;
74676   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74677   float result;
74678
74679   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74680   {
74681     try {
74682       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74683     } catch (std::out_of_range& e) {
74684       {
74685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74686       };
74687     } catch (std::exception& e) {
74688       {
74689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74690       };
74691     } catch (Dali::DaliException e) {
74692       {
74693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74694       };
74695     } catch (...) {
74696       {
74697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74698       };
74699     }
74700   }
74701
74702   jresult = result;
74703   return jresult;
74704 }
74705
74706
74707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74708   void * jresult ;
74709   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74710   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74711
74712   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74713   {
74714     try {
74715       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74716     } catch (std::out_of_range& e) {
74717       {
74718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74719       };
74720     } catch (std::exception& e) {
74721       {
74722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74723       };
74724     } catch (Dali::DaliException e) {
74725       {
74726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74727       };
74728     } catch (...) {
74729       {
74730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74731       };
74732     }
74733   }
74734
74735   jresult = (void *)result;
74736   return jresult;
74737 }
74738
74739
74740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74741   void * jresult ;
74742   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74743   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74744
74745   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74746   {
74747     try {
74748       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74749     } catch (std::out_of_range& e) {
74750       {
74751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74752       };
74753     } catch (std::exception& e) {
74754       {
74755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74756       };
74757     } catch (Dali::DaliException e) {
74758       {
74759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74760       };
74761     } catch (...) {
74762       {
74763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74764       };
74765     }
74766   }
74767
74768   jresult = (void *)result;
74769   return jresult;
74770 }
74771
74772
74773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74774   void * jresult ;
74775   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74776   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74777
74778   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74779   {
74780     try {
74781       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74782     } catch (std::out_of_range& e) {
74783       {
74784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74785       };
74786     } catch (std::exception& e) {
74787       {
74788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74789       };
74790     } catch (Dali::DaliException e) {
74791       {
74792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74793       };
74794     } catch (...) {
74795       {
74796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74797       };
74798     }
74799   }
74800
74801   jresult = (void *)result;
74802   return jresult;
74803 }
74804
74805
74806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74807   unsigned int jresult ;
74808   Dali::Toolkit::ControlOrientation::Type arg1 ;
74809   bool result;
74810
74811   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74812   {
74813     try {
74814       result = (bool)Dali::Toolkit::IsVertical(arg1);
74815     } catch (std::out_of_range& e) {
74816       {
74817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74818       };
74819     } catch (std::exception& e) {
74820       {
74821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74822       };
74823     } catch (Dali::DaliException e) {
74824       {
74825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74826       };
74827     } catch (...) {
74828       {
74829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74830       };
74831     }
74832   }
74833
74834   jresult = result;
74835   return jresult;
74836 }
74837
74838
74839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74840   unsigned int jresult ;
74841   Dali::Toolkit::ControlOrientation::Type arg1 ;
74842   bool result;
74843
74844   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74845   {
74846     try {
74847       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74848     } catch (std::out_of_range& e) {
74849       {
74850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74851       };
74852     } catch (std::exception& e) {
74853       {
74854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74855       };
74856     } catch (Dali::DaliException e) {
74857       {
74858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74859       };
74860     } catch (...) {
74861       {
74862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74863       };
74864     }
74865   }
74866
74867   jresult = result;
74868   return jresult;
74869 }
74870
74871
74872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74873   void * jresult ;
74874   unsigned int arg1 ;
74875   unsigned int arg2 ;
74876   Dali::Toolkit::ItemRange *result = 0 ;
74877
74878   arg1 = (unsigned int)jarg1;
74879   arg2 = (unsigned int)jarg2;
74880   {
74881     try {
74882       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74883     } catch (std::out_of_range& e) {
74884       {
74885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74886       };
74887     } catch (std::exception& e) {
74888       {
74889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74890       };
74891     } catch (Dali::DaliException e) {
74892       {
74893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74894       };
74895     } catch (...) {
74896       {
74897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74898       };
74899     }
74900   }
74901
74902   jresult = (void *)result;
74903   return jresult;
74904 }
74905
74906
74907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74908   void * jresult ;
74909   Dali::Toolkit::ItemRange *arg1 = 0 ;
74910   Dali::Toolkit::ItemRange *result = 0 ;
74911
74912   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74913   if (!arg1) {
74914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74915     return 0;
74916   }
74917   {
74918     try {
74919       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74920     } catch (std::out_of_range& e) {
74921       {
74922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74923       };
74924     } catch (std::exception& e) {
74925       {
74926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74927       };
74928     } catch (Dali::DaliException e) {
74929       {
74930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74931       };
74932     } catch (...) {
74933       {
74934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74935       };
74936     }
74937   }
74938
74939   jresult = (void *)result;
74940   return jresult;
74941 }
74942
74943
74944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74945   void * jresult ;
74946   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74947   Dali::Toolkit::ItemRange *arg2 = 0 ;
74948   Dali::Toolkit::ItemRange *result = 0 ;
74949
74950   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74951   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74952   if (!arg2) {
74953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74954     return 0;
74955   }
74956   {
74957     try {
74958       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74959     } catch (std::out_of_range& e) {
74960       {
74961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74962       };
74963     } catch (std::exception& e) {
74964       {
74965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74966       };
74967     } catch (Dali::DaliException e) {
74968       {
74969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74970       };
74971     } catch (...) {
74972       {
74973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74974       };
74975     }
74976   }
74977
74978   jresult = (void *)result;
74979   return jresult;
74980 }
74981
74982
74983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74984   unsigned int jresult ;
74985   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74986   unsigned int arg2 ;
74987   bool result;
74988
74989   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74990   arg2 = (unsigned int)jarg2;
74991   {
74992     try {
74993       result = (bool)(arg1)->Within(arg2);
74994     } catch (std::out_of_range& e) {
74995       {
74996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74997       };
74998     } catch (std::exception& e) {
74999       {
75000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75001       };
75002     } catch (Dali::DaliException e) {
75003       {
75004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75005       };
75006     } catch (...) {
75007       {
75008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75009       };
75010     }
75011   }
75012
75013   jresult = result;
75014   return jresult;
75015 }
75016
75017
75018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75019   void * jresult ;
75020   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75021   Dali::Toolkit::ItemRange *arg2 = 0 ;
75022   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75023
75024   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75025   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75026   if (!arg2) {
75027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75028     return 0;
75029   }
75030   {
75031     try {
75032       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75033     } catch (std::out_of_range& e) {
75034       {
75035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75036       };
75037     } catch (std::exception& e) {
75038       {
75039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75040       };
75041     } catch (Dali::DaliException e) {
75042       {
75043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75044       };
75045     } catch (...) {
75046       {
75047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75048       };
75049     }
75050   }
75051
75052   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75053   return jresult;
75054 }
75055
75056
75057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75058   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75059   unsigned int arg2 ;
75060
75061   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75062   arg2 = (unsigned int)jarg2;
75063   if (arg1) (arg1)->begin = arg2;
75064 }
75065
75066
75067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75068   unsigned int jresult ;
75069   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75070   unsigned int result;
75071
75072   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75073   result = (unsigned int) ((arg1)->begin);
75074   jresult = result;
75075   return jresult;
75076 }
75077
75078
75079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75080   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75081   unsigned int arg2 ;
75082
75083   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75084   arg2 = (unsigned int)jarg2;
75085   if (arg1) (arg1)->end = arg2;
75086 }
75087
75088
75089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75090   unsigned int jresult ;
75091   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75092   unsigned int result;
75093
75094   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75095   result = (unsigned int) ((arg1)->end);
75096   jresult = result;
75097   return jresult;
75098 }
75099
75100
75101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75102   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75103
75104   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75105   {
75106     try {
75107       delete arg1;
75108     } catch (std::out_of_range& e) {
75109       {
75110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75111       };
75112     } catch (std::exception& e) {
75113       {
75114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75115       };
75116     } catch (Dali::DaliException e) {
75117       {
75118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75119       };
75120     } catch (...) {
75121       {
75122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75123       };
75124     }
75125   }
75126
75127 }
75128
75129
75130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75131   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75132
75133   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75134   {
75135     try {
75136       delete arg1;
75137     } catch (std::out_of_range& e) {
75138       {
75139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75140       };
75141     } catch (std::exception& e) {
75142       {
75143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75144       };
75145     } catch (Dali::DaliException e) {
75146       {
75147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75148       };
75149     } catch (...) {
75150       {
75151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75152       };
75153     }
75154   }
75155
75156 }
75157
75158
75159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75160   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75161   Dali::Toolkit::ControlOrientation::Type arg2 ;
75162
75163   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75164   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75165   {
75166     try {
75167       (arg1)->SetOrientation(arg2);
75168     } catch (std::out_of_range& e) {
75169       {
75170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75171       };
75172     } catch (std::exception& e) {
75173       {
75174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75175       };
75176     } catch (Dali::DaliException e) {
75177       {
75178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75179       };
75180     } catch (...) {
75181       {
75182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75183       };
75184     }
75185   }
75186
75187 }
75188
75189
75190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75191   int jresult ;
75192   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75193   Dali::Toolkit::ControlOrientation::Type result;
75194
75195   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75196   {
75197     try {
75198       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75199     } catch (std::out_of_range& e) {
75200       {
75201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75202       };
75203     } catch (std::exception& e) {
75204       {
75205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75206       };
75207     } catch (Dali::DaliException e) {
75208       {
75209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75210       };
75211     } catch (...) {
75212       {
75213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75214       };
75215     }
75216   }
75217
75218   jresult = (int)result;
75219   return jresult;
75220 }
75221
75222
75223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75224   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75225   Dali::Property::Map *arg2 = 0 ;
75226
75227   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75228   arg2 = (Dali::Property::Map *)jarg2;
75229   if (!arg2) {
75230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75231     return ;
75232   }
75233   {
75234     try {
75235       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75236     } catch (std::out_of_range& e) {
75237       {
75238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75239       };
75240     } catch (std::exception& e) {
75241       {
75242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75243       };
75244     } catch (Dali::DaliException e) {
75245       {
75246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75247       };
75248     } catch (...) {
75249       {
75250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75251       };
75252     }
75253   }
75254
75255 }
75256
75257
75258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75259   void * jresult ;
75260   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75261   Dali::Property::Map result;
75262
75263   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75264   {
75265     try {
75266       result = (arg1)->GetLayoutProperties();
75267     } catch (std::out_of_range& e) {
75268       {
75269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75270       };
75271     } catch (std::exception& e) {
75272       {
75273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75274       };
75275     } catch (Dali::DaliException e) {
75276       {
75277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75278       };
75279     } catch (...) {
75280       {
75281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75282       };
75283     }
75284   }
75285
75286   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75287   return jresult;
75288 }
75289
75290
75291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75292   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75293   unsigned int arg2 ;
75294   Dali::Vector3 *arg3 = 0 ;
75295   Dali::Vector3 *arg4 = 0 ;
75296
75297   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75298   arg2 = (unsigned int)jarg2;
75299   arg3 = (Dali::Vector3 *)jarg3;
75300   if (!arg3) {
75301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75302     return ;
75303   }
75304   arg4 = (Dali::Vector3 *)jarg4;
75305   if (!arg4) {
75306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75307     return ;
75308   }
75309   {
75310     try {
75311       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75312     } catch (std::out_of_range& e) {
75313       {
75314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75315       };
75316     } catch (std::exception& e) {
75317       {
75318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75319       };
75320     } catch (Dali::DaliException e) {
75321       {
75322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75323       };
75324     } catch (...) {
75325       {
75326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75327       };
75328     }
75329   }
75330
75331 }
75332
75333
75334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75335   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75336   Dali::Vector3 *arg2 = 0 ;
75337
75338   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75339   arg2 = (Dali::Vector3 *)jarg2;
75340   if (!arg2) {
75341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75342     return ;
75343   }
75344   {
75345     try {
75346       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75347     } catch (std::out_of_range& e) {
75348       {
75349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75350       };
75351     } catch (std::exception& e) {
75352       {
75353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75354       };
75355     } catch (Dali::DaliException e) {
75356       {
75357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75358       };
75359     } catch (...) {
75360       {
75361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75362       };
75363     }
75364   }
75365
75366 }
75367
75368
75369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75370   float jresult ;
75371   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75372   unsigned int arg2 ;
75373   Dali::Vector3 arg3 ;
75374   Dali::Vector3 *argp3 ;
75375   float result;
75376
75377   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75378   arg2 = (unsigned int)jarg2;
75379   argp3 = (Dali::Vector3 *)jarg3;
75380   if (!argp3) {
75381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75382     return 0;
75383   }
75384   arg3 = *argp3;
75385   {
75386     try {
75387       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75388     } catch (std::out_of_range& e) {
75389       {
75390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75391       };
75392     } catch (std::exception& e) {
75393       {
75394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75395       };
75396     } catch (Dali::DaliException e) {
75397       {
75398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75399       };
75400     } catch (...) {
75401       {
75402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75403       };
75404     }
75405   }
75406
75407   jresult = result;
75408   return jresult;
75409 }
75410
75411
75412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75413   float jresult ;
75414   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75415   float arg2 ;
75416   float result;
75417
75418   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75419   arg2 = (float)jarg2;
75420   {
75421     try {
75422       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75423     } catch (std::out_of_range& e) {
75424       {
75425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75426       };
75427     } catch (std::exception& e) {
75428       {
75429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75430       };
75431     } catch (Dali::DaliException e) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75434       };
75435     } catch (...) {
75436       {
75437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75438       };
75439     }
75440   }
75441
75442   jresult = result;
75443   return jresult;
75444 }
75445
75446
75447 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75448   float jresult ;
75449   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75450   unsigned int arg2 ;
75451   float result;
75452
75453   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75454   arg2 = (unsigned int)jarg2;
75455   {
75456     try {
75457       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75458     } catch (std::out_of_range& e) {
75459       {
75460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75461       };
75462     } catch (std::exception& e) {
75463       {
75464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75465       };
75466     } catch (Dali::DaliException e) {
75467       {
75468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75469       };
75470     } catch (...) {
75471       {
75472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75473       };
75474     }
75475   }
75476
75477   jresult = result;
75478   return jresult;
75479 }
75480
75481
75482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75483   void * jresult ;
75484   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75485   float arg2 ;
75486   Dali::Vector3 arg3 ;
75487   Dali::Vector3 *argp3 ;
75488   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75489
75490   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75491   arg2 = (float)jarg2;
75492   argp3 = (Dali::Vector3 *)jarg3;
75493   if (!argp3) {
75494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75495     return 0;
75496   }
75497   arg3 = *argp3;
75498   {
75499     try {
75500       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75501     } catch (std::out_of_range& e) {
75502       {
75503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75504       };
75505     } catch (std::exception& e) {
75506       {
75507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75508       };
75509     } catch (Dali::DaliException e) {
75510       {
75511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75512       };
75513     } catch (...) {
75514       {
75515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75516       };
75517     }
75518   }
75519
75520   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75521   return jresult;
75522 }
75523
75524
75525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75526   float jresult ;
75527   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75528   int arg2 ;
75529   float arg3 ;
75530   Dali::Vector3 *arg4 = 0 ;
75531   float result;
75532
75533   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75534   arg2 = (int)jarg2;
75535   arg3 = (float)jarg3;
75536   arg4 = (Dali::Vector3 *)jarg4;
75537   if (!arg4) {
75538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75539     return 0;
75540   }
75541   {
75542     try {
75543       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75544     } catch (std::out_of_range& e) {
75545       {
75546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75547       };
75548     } catch (std::exception& e) {
75549       {
75550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75551       };
75552     } catch (Dali::DaliException e) {
75553       {
75554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75555       };
75556     } catch (...) {
75557       {
75558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75559       };
75560     }
75561   }
75562
75563   jresult = result;
75564   return jresult;
75565 }
75566
75567
75568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75569   unsigned int jresult ;
75570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75571   Dali::Vector3 arg2 ;
75572   Dali::Vector3 *argp2 ;
75573   unsigned int result;
75574
75575   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75576   argp2 = (Dali::Vector3 *)jarg2;
75577   if (!argp2) {
75578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75579     return 0;
75580   }
75581   arg2 = *argp2;
75582   {
75583     try {
75584       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75585     } catch (std::out_of_range& e) {
75586       {
75587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75588       };
75589     } catch (std::exception& e) {
75590       {
75591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75592       };
75593     } catch (Dali::DaliException e) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75596       };
75597     } catch (...) {
75598       {
75599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75600       };
75601     }
75602   }
75603
75604   jresult = result;
75605   return jresult;
75606 }
75607
75608
75609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75610   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75611   unsigned int arg2 ;
75612   Dali::Vector3 *arg3 = 0 ;
75613   Dali::Vector3 *arg4 = 0 ;
75614
75615   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75616   arg2 = (unsigned int)jarg2;
75617   arg3 = (Dali::Vector3 *)jarg3;
75618   if (!arg3) {
75619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75620     return ;
75621   }
75622   arg4 = (Dali::Vector3 *)jarg4;
75623   if (!arg4) {
75624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75625     return ;
75626   }
75627   {
75628     try {
75629       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75630     } catch (std::out_of_range& e) {
75631       {
75632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75633       };
75634     } catch (std::exception& e) {
75635       {
75636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75637       };
75638     } catch (Dali::DaliException e) {
75639       {
75640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75641       };
75642     } catch (...) {
75643       {
75644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75645       };
75646     }
75647   }
75648
75649 }
75650
75651
75652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75653   void * jresult ;
75654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75655   Dali::Degree result;
75656
75657   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75658   {
75659     try {
75660       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75661     } catch (std::out_of_range& e) {
75662       {
75663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75664       };
75665     } catch (std::exception& e) {
75666       {
75667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75668       };
75669     } catch (Dali::DaliException e) {
75670       {
75671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75672       };
75673     } catch (...) {
75674       {
75675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75676       };
75677     }
75678   }
75679
75680   jresult = new Dali::Degree((const Dali::Degree &)result);
75681   return jresult;
75682 }
75683
75684
75685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75686   float jresult ;
75687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75688   float result;
75689
75690   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75691   {
75692     try {
75693       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75694     } catch (std::out_of_range& e) {
75695       {
75696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75697       };
75698     } catch (std::exception& e) {
75699       {
75700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75701       };
75702     } catch (Dali::DaliException e) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75705       };
75706     } catch (...) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75709       };
75710     }
75711   }
75712
75713   jresult = result;
75714   return jresult;
75715 }
75716
75717
75718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75719   float jresult ;
75720   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75721   float result;
75722
75723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75724   {
75725     try {
75726       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75727     } catch (std::out_of_range& e) {
75728       {
75729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75730       };
75731     } catch (std::exception& e) {
75732       {
75733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75734       };
75735     } catch (Dali::DaliException e) {
75736       {
75737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75738       };
75739     } catch (...) {
75740       {
75741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75742       };
75743     }
75744   }
75745
75746   jresult = result;
75747   return jresult;
75748 }
75749
75750
75751 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75752   float jresult ;
75753   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75754   float result;
75755
75756   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75757   {
75758     try {
75759       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75760     } catch (std::out_of_range& e) {
75761       {
75762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75763       };
75764     } catch (std::exception& e) {
75765       {
75766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75767       };
75768     } catch (Dali::DaliException e) {
75769       {
75770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75771       };
75772     } catch (...) {
75773       {
75774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75775       };
75776     }
75777   }
75778
75779   jresult = result;
75780   return jresult;
75781 }
75782
75783
75784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75785   int jresult ;
75786   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75787   int arg2 ;
75788   int arg3 ;
75789   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75790   bool arg5 ;
75791   int result;
75792
75793   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75794   arg2 = (int)jarg2;
75795   arg3 = (int)jarg3;
75796   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75797   arg5 = jarg5 ? true : false;
75798   {
75799     try {
75800       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75801     } catch (std::out_of_range& e) {
75802       {
75803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75804       };
75805     } catch (std::exception& e) {
75806       {
75807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75808       };
75809     } catch (Dali::DaliException e) {
75810       {
75811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75816       };
75817     }
75818   }
75819
75820   jresult = result;
75821   return jresult;
75822 }
75823
75824
75825 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75826   float jresult ;
75827   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75828   float result;
75829
75830   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75831   {
75832     try {
75833       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75834     } catch (std::out_of_range& e) {
75835       {
75836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75837       };
75838     } catch (std::exception& e) {
75839       {
75840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75841       };
75842     } catch (Dali::DaliException e) {
75843       {
75844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75845       };
75846     } catch (...) {
75847       {
75848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75849       };
75850     }
75851   }
75852
75853   jresult = result;
75854   return jresult;
75855 }
75856
75857
75858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75859   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75860   Dali::Actor *arg2 = 0 ;
75861   int arg3 ;
75862   Dali::Vector3 *arg4 = 0 ;
75863   Dali::Actor *arg5 = 0 ;
75864
75865   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75866   arg2 = (Dali::Actor *)jarg2;
75867   if (!arg2) {
75868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75869     return ;
75870   }
75871   arg3 = (int)jarg3;
75872   arg4 = (Dali::Vector3 *)jarg4;
75873   if (!arg4) {
75874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75875     return ;
75876   }
75877   arg5 = (Dali::Actor *)jarg5;
75878   if (!arg5) {
75879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75880     return ;
75881   }
75882   {
75883     try {
75884       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75885     } catch (std::out_of_range& e) {
75886       {
75887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75888       };
75889     } catch (std::exception& e) {
75890       {
75891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75892       };
75893     } catch (Dali::DaliException e) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75900       };
75901     }
75902   }
75903
75904 }
75905
75906
75907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75908   void * jresult ;
75909   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75910   int arg2 ;
75911   float arg3 ;
75912   Dali::Vector3 *arg4 = 0 ;
75913   Dali::Vector3 result;
75914
75915   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75916   arg2 = (int)jarg2;
75917   arg3 = (float)jarg3;
75918   arg4 = (Dali::Vector3 *)jarg4;
75919   if (!arg4) {
75920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75921     return 0;
75922   }
75923   {
75924     try {
75925       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75926     } catch (std::out_of_range& e) {
75927       {
75928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75929       };
75930     } catch (std::exception& e) {
75931       {
75932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75933       };
75934     } catch (Dali::DaliException e) {
75935       {
75936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75937       };
75938     } catch (...) {
75939       {
75940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75941       };
75942     }
75943   }
75944
75945   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75946   return jresult;
75947 }
75948
75949
75950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75951   void * jresult ;
75952   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75953   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75954
75955   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75956   {
75957     try {
75958       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75959     } catch (std::out_of_range& e) {
75960       {
75961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75962       };
75963     } catch (std::exception& e) {
75964       {
75965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75966       };
75967     } catch (Dali::DaliException e) {
75968       {
75969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75970       };
75971     } catch (...) {
75972       {
75973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75974       };
75975     }
75976   }
75977
75978   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75979   return jresult;
75980 }
75981
75982
75983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75984   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75985
75986   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75987   {
75988     try {
75989       delete arg1;
75990     } catch (std::out_of_range& e) {
75991       {
75992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75993       };
75994     } catch (std::exception& e) {
75995       {
75996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75997       };
75998     } catch (Dali::DaliException e) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76001       };
76002     } catch (...) {
76003       {
76004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76005       };
76006     }
76007   }
76008
76009 }
76010
76011
76012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76013   unsigned int jresult ;
76014   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76015   unsigned int result;
76016
76017   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76018   {
76019     try {
76020       result = (unsigned int)(arg1)->GetNumberOfItems();
76021     } catch (std::out_of_range& e) {
76022       {
76023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76024       };
76025     } catch (std::exception& e) {
76026       {
76027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76028       };
76029     } catch (Dali::DaliException e) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76032       };
76033     } catch (...) {
76034       {
76035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76036       };
76037     }
76038   }
76039
76040   jresult = result;
76041   return jresult;
76042 }
76043
76044
76045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76046   void * jresult ;
76047   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76048   unsigned int arg2 ;
76049   Dali::Actor result;
76050
76051   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76052   arg2 = (unsigned int)jarg2;
76053   {
76054     try {
76055       result = (arg1)->NewItem(arg2);
76056     } catch (std::out_of_range& e) {
76057       {
76058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76059       };
76060     } catch (std::exception& e) {
76061       {
76062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76063       };
76064     } catch (Dali::DaliException e) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76067       };
76068     } catch (...) {
76069       {
76070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76071       };
76072     }
76073   }
76074
76075   jresult = new Dali::Actor((const Dali::Actor &)result);
76076   return jresult;
76077 }
76078
76079
76080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76081   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76082   unsigned int arg2 ;
76083   Dali::Actor arg3 ;
76084   Dali::Actor *argp3 ;
76085
76086   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76087   arg2 = (unsigned int)jarg2;
76088   argp3 = (Dali::Actor *)jarg3;
76089   if (!argp3) {
76090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76091     return ;
76092   }
76093   arg3 = *argp3;
76094   {
76095     try {
76096       (arg1)->ItemReleased(arg2,arg3);
76097     } catch (std::out_of_range& e) {
76098       {
76099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76100       };
76101     } catch (std::exception& e) {
76102       {
76103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76104       };
76105     } catch (Dali::DaliException e) {
76106       {
76107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76108       };
76109     } catch (...) {
76110       {
76111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76112       };
76113     }
76114   }
76115
76116 }
76117
76118
76119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76120   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76121   unsigned int arg2 ;
76122   Dali::Actor arg3 ;
76123   Dali::Actor *argp3 ;
76124
76125   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76126   arg2 = (unsigned int)jarg2;
76127   argp3 = (Dali::Actor *)jarg3;
76128   if (!argp3) {
76129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76130     return ;
76131   }
76132   arg3 = *argp3;
76133   {
76134     try {
76135       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76136     } catch (std::out_of_range& e) {
76137       {
76138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76139       };
76140     } catch (std::exception& e) {
76141       {
76142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76143       };
76144     } catch (Dali::DaliException e) {
76145       {
76146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76147       };
76148     } catch (...) {
76149       {
76150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76151       };
76152     }
76153   }
76154
76155 }
76156
76157
76158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76159   void * jresult ;
76160   Dali::Toolkit::ItemFactory *result = 0 ;
76161
76162   {
76163     try {
76164       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76165     } catch (std::out_of_range& e) {
76166       {
76167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (std::exception& e) {
76170       {
76171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76172       };
76173     } catch (Dali::DaliException e) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76180       };
76181     }
76182   }
76183
76184   jresult = (void *)result;
76185   return jresult;
76186 }
76187
76188
76189 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) {
76190   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76191   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76192   if (director) {
76193     director->swig_connect_director(callback0, callback1, callback2);
76194   }
76195 }
76196
76197
76198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76199   int jresult ;
76200   int result;
76201
76202   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76203   jresult = (int)result;
76204   return jresult;
76205 }
76206
76207
76208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76209   int jresult ;
76210   int result;
76211
76212   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76213   jresult = (int)result;
76214   return jresult;
76215 }
76216
76217
76218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76219   int jresult ;
76220   int result;
76221
76222   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76223   jresult = (int)result;
76224   return jresult;
76225 }
76226
76227
76228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76229   int jresult ;
76230   int result;
76231
76232   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76233   jresult = (int)result;
76234   return jresult;
76235 }
76236
76237
76238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76239   int jresult ;
76240   int result;
76241
76242   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76243   jresult = (int)result;
76244   return jresult;
76245 }
76246
76247
76248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76249   int jresult ;
76250   int result;
76251
76252   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76253   jresult = (int)result;
76254   return jresult;
76255 }
76256
76257
76258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76259   int jresult ;
76260   int result;
76261
76262   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76263   jresult = (int)result;
76264   return jresult;
76265 }
76266
76267
76268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76269   int jresult ;
76270   int result;
76271
76272   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76273   jresult = (int)result;
76274   return jresult;
76275 }
76276
76277
76278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76279   int jresult ;
76280   int result;
76281
76282   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76283   jresult = (int)result;
76284   return jresult;
76285 }
76286
76287
76288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76289   int jresult ;
76290   int result;
76291
76292   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76293   jresult = (int)result;
76294   return jresult;
76295 }
76296
76297
76298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76299   int jresult ;
76300   int result;
76301
76302   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76303   jresult = (int)result;
76304   return jresult;
76305 }
76306
76307
76308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76309   void * jresult ;
76310   Dali::Toolkit::ItemView::Property *result = 0 ;
76311
76312   {
76313     try {
76314       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76315     } catch (std::out_of_range& e) {
76316       {
76317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (std::exception& e) {
76320       {
76321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (Dali::DaliException e) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76326       };
76327     } catch (...) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76330       };
76331     }
76332   }
76333
76334   jresult = (void *)result;
76335   return jresult;
76336 }
76337
76338
76339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76340   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76341
76342   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76343   {
76344     try {
76345       delete arg1;
76346     } catch (std::out_of_range& e) {
76347       {
76348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76349       };
76350     } catch (std::exception& e) {
76351       {
76352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76353       };
76354     } catch (Dali::DaliException e) {
76355       {
76356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76357       };
76358     } catch (...) {
76359       {
76360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76361       };
76362     }
76363   }
76364
76365 }
76366
76367
76368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76369   void * jresult ;
76370   Dali::Toolkit::ItemView *result = 0 ;
76371
76372   {
76373     try {
76374       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76375     } catch (std::out_of_range& e) {
76376       {
76377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76378       };
76379     } catch (std::exception& e) {
76380       {
76381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76382       };
76383     } catch (Dali::DaliException e) {
76384       {
76385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76386       };
76387     } catch (...) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76390       };
76391     }
76392   }
76393
76394   jresult = (void *)result;
76395   return jresult;
76396 }
76397
76398
76399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76400   void * jresult ;
76401   Dali::Toolkit::ItemView *arg1 = 0 ;
76402   Dali::Toolkit::ItemView *result = 0 ;
76403
76404   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76405   if (!arg1) {
76406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76407     return 0;
76408   }
76409   {
76410     try {
76411       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76412     } catch (std::out_of_range& e) {
76413       {
76414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76415       };
76416     } catch (std::exception& e) {
76417       {
76418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76419       };
76420     } catch (Dali::DaliException e) {
76421       {
76422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76423       };
76424     } catch (...) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76427       };
76428     }
76429   }
76430
76431   jresult = (void *)result;
76432   return jresult;
76433 }
76434
76435
76436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76437   void * jresult ;
76438   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76439   Dali::Toolkit::ItemView *arg2 = 0 ;
76440   Dali::Toolkit::ItemView *result = 0 ;
76441
76442   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76443   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76444   if (!arg2) {
76445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76446     return 0;
76447   }
76448   {
76449     try {
76450       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76451     } catch (std::out_of_range& e) {
76452       {
76453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76454       };
76455     } catch (std::exception& e) {
76456       {
76457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76458       };
76459     } catch (Dali::DaliException e) {
76460       {
76461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76462       };
76463     } catch (...) {
76464       {
76465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76466       };
76467     }
76468   }
76469
76470   jresult = (void *)result;
76471   return jresult;
76472 }
76473
76474
76475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76476   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76477
76478   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76479   {
76480     try {
76481       delete arg1;
76482     } catch (std::out_of_range& e) {
76483       {
76484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76485       };
76486     } catch (std::exception& e) {
76487       {
76488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76489       };
76490     } catch (Dali::DaliException e) {
76491       {
76492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76493       };
76494     } catch (...) {
76495       {
76496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76497       };
76498     }
76499   }
76500
76501 }
76502
76503
76504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76505   void * jresult ;
76506   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76507   Dali::Toolkit::ItemView result;
76508
76509   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76510   if (!arg1) {
76511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76512     return 0;
76513   }
76514   {
76515     try {
76516       result = Dali::Toolkit::ItemView::New(*arg1);
76517     } catch (std::out_of_range& e) {
76518       {
76519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76520       };
76521     } catch (std::exception& e) {
76522       {
76523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76524       };
76525     } catch (Dali::DaliException e) {
76526       {
76527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76528       };
76529     } catch (...) {
76530       {
76531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76532       };
76533     }
76534   }
76535
76536   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76537   return jresult;
76538 }
76539
76540
76541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76542   void * jresult ;
76543   Dali::BaseHandle arg1 ;
76544   Dali::BaseHandle *argp1 ;
76545   Dali::Toolkit::ItemView result;
76546
76547   argp1 = (Dali::BaseHandle *)jarg1;
76548   if (!argp1) {
76549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76550     return 0;
76551   }
76552   arg1 = *argp1;
76553   {
76554     try {
76555       result = Dali::Toolkit::ItemView::DownCast(arg1);
76556     } catch (std::out_of_range& e) {
76557       {
76558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76559       };
76560     } catch (std::exception& e) {
76561       {
76562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76563       };
76564     } catch (Dali::DaliException e) {
76565       {
76566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76567       };
76568     } catch (...) {
76569       {
76570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76571       };
76572     }
76573   }
76574
76575   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76576   return jresult;
76577 }
76578
76579
76580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76581   unsigned int jresult ;
76582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76583   unsigned int result;
76584
76585   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76586   {
76587     try {
76588       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76589     } catch (std::out_of_range& e) {
76590       {
76591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76592       };
76593     } catch (std::exception& e) {
76594       {
76595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76596       };
76597     } catch (Dali::DaliException e) {
76598       {
76599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76600       };
76601     } catch (...) {
76602       {
76603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76604       };
76605     }
76606   }
76607
76608   jresult = result;
76609   return jresult;
76610 }
76611
76612
76613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76615   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76616
76617   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76618   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76619   if (!arg2) {
76620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76621     return ;
76622   }
76623   {
76624     try {
76625       (arg1)->AddLayout(*arg2);
76626     } catch (std::out_of_range& e) {
76627       {
76628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76629       };
76630     } catch (std::exception& e) {
76631       {
76632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76633       };
76634     } catch (Dali::DaliException e) {
76635       {
76636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76637       };
76638     } catch (...) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76641       };
76642     }
76643   }
76644
76645 }
76646
76647
76648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76649   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76650   unsigned int arg2 ;
76651
76652   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76653   arg2 = (unsigned int)jarg2;
76654   {
76655     try {
76656       (arg1)->RemoveLayout(arg2);
76657     } catch (std::out_of_range& e) {
76658       {
76659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76660       };
76661     } catch (std::exception& e) {
76662       {
76663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76664       };
76665     } catch (Dali::DaliException e) {
76666       {
76667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76668       };
76669     } catch (...) {
76670       {
76671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76672       };
76673     }
76674   }
76675
76676 }
76677
76678
76679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76680   void * jresult ;
76681   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76682   unsigned int arg2 ;
76683   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76684
76685   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76686   arg2 = (unsigned int)jarg2;
76687   {
76688     try {
76689       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76690     } catch (std::out_of_range& e) {
76691       {
76692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76693       };
76694     } catch (std::exception& e) {
76695       {
76696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76697       };
76698     } catch (Dali::DaliException e) {
76699       {
76700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76701       };
76702     } catch (...) {
76703       {
76704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76705       };
76706     }
76707   }
76708
76709   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76710   return jresult;
76711 }
76712
76713
76714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76715   void * jresult ;
76716   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76717   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76718
76719   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76720   {
76721     try {
76722       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76723     } catch (std::out_of_range& e) {
76724       {
76725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76726       };
76727     } catch (std::exception& e) {
76728       {
76729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76730       };
76731     } catch (Dali::DaliException e) {
76732       {
76733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76734       };
76735     } catch (...) {
76736       {
76737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76738       };
76739     }
76740   }
76741
76742   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76743   return jresult;
76744 }
76745
76746
76747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76748   float jresult ;
76749   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76750   Dali::Toolkit::ItemId arg2 ;
76751   float result;
76752
76753   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76754   arg2 = (Dali::Toolkit::ItemId)jarg2;
76755   {
76756     try {
76757       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76758     } catch (std::out_of_range& e) {
76759       {
76760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76761       };
76762     } catch (std::exception& e) {
76763       {
76764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76765       };
76766     } catch (Dali::DaliException e) {
76767       {
76768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76769       };
76770     } catch (...) {
76771       {
76772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76773       };
76774     }
76775   }
76776
76777   jresult = result;
76778   return jresult;
76779 }
76780
76781
76782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76783   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76784   unsigned int arg2 ;
76785   Dali::Vector3 arg3 ;
76786   float arg4 ;
76787   Dali::Vector3 *argp3 ;
76788
76789   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76790   arg2 = (unsigned int)jarg2;
76791   argp3 = (Dali::Vector3 *)jarg3;
76792   if (!argp3) {
76793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76794     return ;
76795   }
76796   arg3 = *argp3;
76797   arg4 = (float)jarg4;
76798   {
76799     try {
76800       (arg1)->ActivateLayout(arg2,arg3,arg4);
76801     } catch (std::out_of_range& e) {
76802       {
76803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76804       };
76805     } catch (std::exception& e) {
76806       {
76807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76808       };
76809     } catch (Dali::DaliException e) {
76810       {
76811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76812       };
76813     } catch (...) {
76814       {
76815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76816       };
76817     }
76818   }
76819
76820 }
76821
76822
76823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76825
76826   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76827   {
76828     try {
76829       (arg1)->DeactivateCurrentLayout();
76830     } catch (std::out_of_range& e) {
76831       {
76832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76833       };
76834     } catch (std::exception& e) {
76835       {
76836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76837       };
76838     } catch (Dali::DaliException e) {
76839       {
76840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76841       };
76842     } catch (...) {
76843       {
76844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76845       };
76846     }
76847   }
76848
76849 }
76850
76851
76852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(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)->SetMinimumSwipeSpeed(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_GetMinimumSwipeSpeed(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)->GetMinimumSwipeSpeed();
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_SetMinimumSwipeDistance(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)->SetMinimumSwipeDistance(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_GetMinimumSwipeDistance(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)->GetMinimumSwipeDistance();
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_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76981   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76982   float arg2 ;
76983
76984   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76985   arg2 = (float)jarg2;
76986   {
76987     try {
76988       (arg1)->SetWheelScrollDistanceStep(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
77011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77012   float jresult ;
77013   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77014   float result;
77015
77016   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77017   {
77018     try {
77019       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77020     } catch (std::out_of_range& e) {
77021       {
77022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77023       };
77024     } catch (std::exception& e) {
77025       {
77026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77027       };
77028     } catch (Dali::DaliException e) {
77029       {
77030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77031       };
77032     } catch (...) {
77033       {
77034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77035       };
77036     }
77037   }
77038
77039   jresult = result;
77040   return jresult;
77041 }
77042
77043
77044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77045   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77046   bool arg2 ;
77047
77048   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77049   arg2 = jarg2 ? true : false;
77050   {
77051     try {
77052       (arg1)->SetAnchoring(arg2);
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77068       };
77069     }
77070   }
77071
77072 }
77073
77074 //// ========================= end of part 3 =============================
77075
77076 //// ========================== start part 4 ===============================
77077
77078
77079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77080   unsigned int jresult ;
77081   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77082   bool result;
77083
77084   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77085   {
77086     try {
77087       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
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_SetAnchoringDuration(void * jarg1, float jarg2) {
77113   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77114   float arg2 ;
77115
77116   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77117   arg2 = (float)jarg2;
77118   {
77119     try {
77120       (arg1)->SetAnchoringDuration(arg2);
77121     } catch (std::out_of_range& e) {
77122       {
77123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77124       };
77125     } catch (std::exception& e) {
77126       {
77127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77128       };
77129     } catch (Dali::DaliException e) {
77130       {
77131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77132       };
77133     } catch (...) {
77134       {
77135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77136       };
77137     }
77138   }
77139
77140 }
77141
77142
77143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77144   float jresult ;
77145   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77146   float result;
77147
77148   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77149   {
77150     try {
77151       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77152     } catch (std::out_of_range& e) {
77153       {
77154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77155       };
77156     } catch (std::exception& e) {
77157       {
77158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77159       };
77160     } catch (Dali::DaliException e) {
77161       {
77162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77163       };
77164     } catch (...) {
77165       {
77166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77167       };
77168     }
77169   }
77170
77171   jresult = result;
77172   return jresult;
77173 }
77174
77175
77176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77177   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77178   Dali::Toolkit::ItemId arg2 ;
77179   float arg3 ;
77180
77181   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77182   arg2 = (Dali::Toolkit::ItemId)jarg2;
77183   arg3 = (float)jarg3;
77184   {
77185     try {
77186       (arg1)->ScrollToItem(arg2,arg3);
77187     } catch (std::out_of_range& e) {
77188       {
77189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77190       };
77191     } catch (std::exception& e) {
77192       {
77193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77194       };
77195     } catch (Dali::DaliException e) {
77196       {
77197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77198       };
77199     } catch (...) {
77200       {
77201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77202       };
77203     }
77204   }
77205
77206 }
77207
77208
77209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77210   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77211   float arg2 ;
77212
77213   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77214   arg2 = (float)jarg2;
77215   {
77216     try {
77217       (arg1)->SetRefreshInterval(arg2);
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77225       };
77226     } catch (Dali::DaliException e) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77229       };
77230     } catch (...) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77233       };
77234     }
77235   }
77236
77237 }
77238
77239
77240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77241   float jresult ;
77242   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77243   float result;
77244
77245   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77246   {
77247     try {
77248       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
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 = result;
77269   return jresult;
77270 }
77271
77272
77273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77274   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77275
77276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77277   {
77278     try {
77279       (arg1)->Refresh();
77280     } catch (std::out_of_range& e) {
77281       {
77282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77283       };
77284     } catch (std::exception& e) {
77285       {
77286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77287       };
77288     } catch (Dali::DaliException e) {
77289       {
77290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77291       };
77292     } catch (...) {
77293       {
77294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77295       };
77296     }
77297   }
77298
77299 }
77300
77301
77302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77303   void * jresult ;
77304   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77305   Dali::Toolkit::ItemId arg2 ;
77306   Dali::Actor result;
77307
77308   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77309   arg2 = (Dali::Toolkit::ItemId)jarg2;
77310   {
77311     try {
77312       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77313     } catch (std::out_of_range& e) {
77314       {
77315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77316       };
77317     } catch (std::exception& e) {
77318       {
77319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77320       };
77321     } catch (Dali::DaliException e) {
77322       {
77323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77324       };
77325     } catch (...) {
77326       {
77327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77328       };
77329     }
77330   }
77331
77332   jresult = new Dali::Actor((const Dali::Actor &)result);
77333   return jresult;
77334 }
77335
77336
77337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77338   unsigned int jresult ;
77339   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77340   Dali::Actor arg2 ;
77341   Dali::Actor *argp2 ;
77342   Dali::Toolkit::ItemId result;
77343
77344   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77345   argp2 = (Dali::Actor *)jarg2;
77346   if (!argp2) {
77347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77348     return 0;
77349   }
77350   arg2 = *argp2;
77351   {
77352     try {
77353       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77354     } catch (std::out_of_range& e) {
77355       {
77356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77357       };
77358     } catch (std::exception& e) {
77359       {
77360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77361       };
77362     } catch (Dali::DaliException e) {
77363       {
77364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77365       };
77366     } catch (...) {
77367       {
77368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77369       };
77370     }
77371   }
77372
77373   jresult = result;
77374   return jresult;
77375 }
77376
77377
77378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77379   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77380   Dali::Toolkit::Item arg2 ;
77381   float arg3 ;
77382   Dali::Toolkit::Item *argp2 ;
77383
77384   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77385   argp2 = (Dali::Toolkit::Item *)jarg2;
77386   if (!argp2) {
77387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77388     return ;
77389   }
77390   arg2 = *argp2;
77391   arg3 = (float)jarg3;
77392   {
77393     try {
77394       (arg1)->InsertItem(arg2,arg3);
77395     } catch (std::out_of_range& e) {
77396       {
77397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77398       };
77399     } catch (std::exception& e) {
77400       {
77401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77402       };
77403     } catch (Dali::DaliException e) {
77404       {
77405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77406       };
77407     } catch (...) {
77408       {
77409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77410       };
77411     }
77412   }
77413
77414 }
77415
77416
77417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77418   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77419   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77420   float arg3 ;
77421
77422   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77423   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77424   if (!arg2) {
77425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77426     return ;
77427   }
77428   arg3 = (float)jarg3;
77429   {
77430     try {
77431       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77432     } catch (std::out_of_range& e) {
77433       {
77434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77435       };
77436     } catch (std::exception& e) {
77437       {
77438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77439       };
77440     } catch (Dali::DaliException e) {
77441       {
77442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77443       };
77444     } catch (...) {
77445       {
77446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77447       };
77448     }
77449   }
77450
77451 }
77452
77453
77454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77455   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77456   Dali::Toolkit::ItemId arg2 ;
77457   float arg3 ;
77458
77459   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77460   arg2 = (Dali::Toolkit::ItemId)jarg2;
77461   arg3 = (float)jarg3;
77462   {
77463     try {
77464       (arg1)->RemoveItem(arg2,arg3);
77465     } catch (std::out_of_range& e) {
77466       {
77467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77468       };
77469     } catch (std::exception& e) {
77470       {
77471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77472       };
77473     } catch (Dali::DaliException e) {
77474       {
77475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77476       };
77477     } catch (...) {
77478       {
77479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77480       };
77481     }
77482   }
77483
77484 }
77485
77486
77487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77488   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77489   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77490   float arg3 ;
77491
77492   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77493   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77494   if (!arg2) {
77495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77496     return ;
77497   }
77498   arg3 = (float)jarg3;
77499   {
77500     try {
77501       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77502     } catch (std::out_of_range& e) {
77503       {
77504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77505       };
77506     } catch (std::exception& e) {
77507       {
77508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77509       };
77510     } catch (Dali::DaliException e) {
77511       {
77512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77513       };
77514     } catch (...) {
77515       {
77516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77517       };
77518     }
77519   }
77520
77521 }
77522
77523
77524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77525   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77526   Dali::Toolkit::Item arg2 ;
77527   float arg3 ;
77528   Dali::Toolkit::Item *argp2 ;
77529
77530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77531   argp2 = (Dali::Toolkit::Item *)jarg2;
77532   if (!argp2) {
77533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77534     return ;
77535   }
77536   arg2 = *argp2;
77537   arg3 = (float)jarg3;
77538   {
77539     try {
77540       (arg1)->ReplaceItem(arg2,arg3);
77541     } catch (std::out_of_range& e) {
77542       {
77543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77544       };
77545     } catch (std::exception& e) {
77546       {
77547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77548       };
77549     } catch (Dali::DaliException e) {
77550       {
77551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77552       };
77553     } catch (...) {
77554       {
77555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77556       };
77557     }
77558   }
77559
77560 }
77561
77562
77563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77564   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77565   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77566   float arg3 ;
77567
77568   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77569   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77570   if (!arg2) {
77571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77572     return ;
77573   }
77574   arg3 = (float)jarg3;
77575   {
77576     try {
77577       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77578     } catch (std::out_of_range& e) {
77579       {
77580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77581       };
77582     } catch (std::exception& e) {
77583       {
77584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77585       };
77586     } catch (Dali::DaliException e) {
77587       {
77588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77589       };
77590     } catch (...) {
77591       {
77592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77593       };
77594     }
77595   }
77596
77597 }
77598
77599
77600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77601   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77602   Dali::Vector3 *arg2 = 0 ;
77603
77604   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77605   arg2 = (Dali::Vector3 *)jarg2;
77606   if (!arg2) {
77607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77608     return ;
77609   }
77610   {
77611     try {
77612       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77613     } catch (std::out_of_range& e) {
77614       {
77615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77616       };
77617     } catch (std::exception& e) {
77618       {
77619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77620       };
77621     } catch (Dali::DaliException e) {
77622       {
77623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77624       };
77625     } catch (...) {
77626       {
77627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77628       };
77629     }
77630   }
77631
77632 }
77633
77634
77635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77636   void * jresult ;
77637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77638   Dali::Vector3 result;
77639
77640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77641   {
77642     try {
77643       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77644     } catch (std::out_of_range& e) {
77645       {
77646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77647       };
77648     } catch (std::exception& e) {
77649       {
77650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77651       };
77652     } catch (Dali::DaliException e) {
77653       {
77654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77655       };
77656     } catch (...) {
77657       {
77658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77659       };
77660     }
77661   }
77662
77663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77664   return jresult;
77665 }
77666
77667
77668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77669   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77670   Dali::Vector3 *arg2 = 0 ;
77671
77672   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77673   arg2 = (Dali::Vector3 *)jarg2;
77674   if (!arg2) {
77675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77676     return ;
77677   }
77678   {
77679     try {
77680       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77681     } catch (std::out_of_range& e) {
77682       {
77683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77684       };
77685     } catch (std::exception& e) {
77686       {
77687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77688       };
77689     } catch (Dali::DaliException e) {
77690       {
77691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77692       };
77693     } catch (...) {
77694       {
77695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77696       };
77697     }
77698   }
77699
77700 }
77701
77702
77703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77704   void * jresult ;
77705   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77706   Dali::Vector3 result;
77707
77708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77709   {
77710     try {
77711       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77712     } catch (std::out_of_range& e) {
77713       {
77714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77715       };
77716     } catch (std::exception& e) {
77717       {
77718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77719       };
77720     } catch (Dali::DaliException e) {
77721       {
77722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77723       };
77724     } catch (...) {
77725       {
77726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77727       };
77728     }
77729   }
77730
77731   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77732   return jresult;
77733 }
77734
77735
77736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77737   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77738   Dali::Toolkit::ItemRange *arg2 = 0 ;
77739
77740   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77741   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77742   if (!arg2) {
77743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77744     return ;
77745   }
77746   {
77747     try {
77748       (arg1)->GetItemsRange(*arg2);
77749     } catch (std::out_of_range& e) {
77750       {
77751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77752       };
77753     } catch (std::exception& e) {
77754       {
77755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77756       };
77757     } catch (Dali::DaliException e) {
77758       {
77759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77760       };
77761     } catch (...) {
77762       {
77763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77764       };
77765     }
77766   }
77767
77768 }
77769
77770
77771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77772   void * jresult ;
77773   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77774   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77775
77776   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77777   {
77778     try {
77779       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77780     } catch (std::out_of_range& e) {
77781       {
77782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77783       };
77784     } catch (std::exception& e) {
77785       {
77786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77787       };
77788     } catch (Dali::DaliException e) {
77789       {
77790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77791       };
77792     } catch (...) {
77793       {
77794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77795       };
77796     }
77797   }
77798
77799   jresult = (void *)result;
77800   return jresult;
77801 }
77802
77803
77804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77805   Dali::Vector3 *arg1 = 0 ;
77806   PropertyInputContainer *arg2 = 0 ;
77807
77808   arg1 = (Dali::Vector3 *)jarg1;
77809   if (!arg1) {
77810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77811     return ;
77812   }
77813   arg2 = (PropertyInputContainer *)jarg2;
77814   if (!arg2) {
77815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77816     return ;
77817   }
77818   {
77819     try {
77820       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77821     } catch (std::out_of_range& e) {
77822       {
77823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77824       };
77825     } catch (std::exception& e) {
77826       {
77827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77828       };
77829     } catch (Dali::DaliException e) {
77830       {
77831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77832       };
77833     } catch (...) {
77834       {
77835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77836       };
77837     }
77838   }
77839
77840 }
77841
77842
77843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77844   Dali::Vector3 *arg1 = 0 ;
77845   PropertyInputContainer *arg2 = 0 ;
77846
77847   arg1 = (Dali::Vector3 *)jarg1;
77848   if (!arg1) {
77849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77850     return ;
77851   }
77852   arg2 = (PropertyInputContainer *)jarg2;
77853   if (!arg2) {
77854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77855     return ;
77856   }
77857   {
77858     try {
77859       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77860     } catch (std::out_of_range& e) {
77861       {
77862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77863       };
77864     } catch (std::exception& e) {
77865       {
77866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77867       };
77868     } catch (Dali::DaliException e) {
77869       {
77870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77871       };
77872     } catch (...) {
77873       {
77874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77875       };
77876     }
77877   }
77878
77879 }
77880
77881
77882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77883   void * jresult ;
77884   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77885
77886   {
77887     try {
77888       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77889     } catch (std::out_of_range& e) {
77890       {
77891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77892       };
77893     } catch (std::exception& e) {
77894       {
77895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77896       };
77897     } catch (Dali::DaliException e) {
77898       {
77899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77900       };
77901     } catch (...) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77904       };
77905     }
77906   }
77907
77908   jresult = (void *)result;
77909   return jresult;
77910 }
77911
77912
77913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77914   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77915
77916   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77917   {
77918     try {
77919       delete arg1;
77920     } catch (std::out_of_range& e) {
77921       {
77922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77923       };
77924     } catch (std::exception& e) {
77925       {
77926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77927       };
77928     } catch (Dali::DaliException e) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77931       };
77932     } catch (...) {
77933       {
77934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77935       };
77936     }
77937   }
77938
77939 }
77940
77941
77942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77943   void * jresult ;
77944   Dali::Path arg1 ;
77945   Dali::Vector3 *arg2 = 0 ;
77946   Dali::Property::Index arg3 ;
77947   Dali::Vector3 *arg4 = 0 ;
77948   unsigned int arg5 ;
77949   Dali::Path *argp1 ;
77950   Dali::Toolkit::ScrollViewPagePathEffect result;
77951
77952   argp1 = (Dali::Path *)jarg1;
77953   if (!argp1) {
77954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77955     return 0;
77956   }
77957   arg1 = *argp1;
77958   arg2 = (Dali::Vector3 *)jarg2;
77959   if (!arg2) {
77960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77961     return 0;
77962   }
77963   arg3 = (Dali::Property::Index)jarg3;
77964   arg4 = (Dali::Vector3 *)jarg4;
77965   if (!arg4) {
77966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77967     return 0;
77968   }
77969   arg5 = (unsigned int)jarg5;
77970   {
77971     try {
77972       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77973     } catch (std::out_of_range& e) {
77974       {
77975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77976       };
77977     } catch (std::exception& e) {
77978       {
77979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77980       };
77981     } catch (Dali::DaliException e) {
77982       {
77983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77984       };
77985     } catch (...) {
77986       {
77987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77988       };
77989     }
77990   }
77991
77992   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77993   return jresult;
77994 }
77995
77996
77997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77998   void * jresult ;
77999   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78000
78001   {
78002     try {
78003       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78004     } catch (std::out_of_range& e) {
78005       {
78006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78007       };
78008     } catch (std::exception& e) {
78009       {
78010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78011       };
78012     } catch (Dali::DaliException e) {
78013       {
78014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78015       };
78016     } catch (...) {
78017       {
78018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78019       };
78020     }
78021   }
78022
78023   jresult = (void *)result;
78024   return jresult;
78025 }
78026
78027
78028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78029   void * jresult ;
78030   Dali::BaseHandle arg1 ;
78031   Dali::BaseHandle *argp1 ;
78032   Dali::Toolkit::ScrollViewPagePathEffect result;
78033
78034   argp1 = (Dali::BaseHandle *)jarg1;
78035   if (!argp1) {
78036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78037     return 0;
78038   }
78039   arg1 = *argp1;
78040   {
78041     try {
78042       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78043     } catch (std::out_of_range& e) {
78044       {
78045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78046       };
78047     } catch (std::exception& e) {
78048       {
78049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78050       };
78051     } catch (Dali::DaliException e) {
78052       {
78053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78054       };
78055     } catch (...) {
78056       {
78057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78058       };
78059     }
78060   }
78061
78062   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78063   return jresult;
78064 }
78065
78066
78067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78068   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78069   Dali::Actor arg2 ;
78070   unsigned int arg3 ;
78071   Dali::Actor *argp2 ;
78072
78073   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78074   argp2 = (Dali::Actor *)jarg2;
78075   if (!argp2) {
78076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78077     return ;
78078   }
78079   arg2 = *argp2;
78080   arg3 = (unsigned int)jarg3;
78081   {
78082     try {
78083       (arg1)->ApplyToPage(arg2,arg3);
78084     } catch (std::out_of_range& e) {
78085       {
78086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78087       };
78088     } catch (std::exception& e) {
78089       {
78090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78091       };
78092     } catch (Dali::DaliException e) {
78093       {
78094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78095       };
78096     } catch (...) {
78097       {
78098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78099       };
78100     }
78101   }
78102
78103 }
78104
78105
78106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78107   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78108
78109   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78110   {
78111     try {
78112       delete arg1;
78113     } catch (std::out_of_range& e) {
78114       {
78115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78116       };
78117     } catch (std::exception& e) {
78118       {
78119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78120       };
78121     } catch (Dali::DaliException e) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78124       };
78125     } catch (...) {
78126       {
78127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78128       };
78129     }
78130   }
78131
78132 }
78133
78134
78135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78136   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78137   Dali::Toolkit::ClampState arg2 ;
78138
78139   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78140   arg2 = (Dali::Toolkit::ClampState)jarg2;
78141   if (arg1) (arg1)->x = arg2;
78142 }
78143
78144
78145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78146   int jresult ;
78147   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78148   Dali::Toolkit::ClampState result;
78149
78150   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78151   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78152   jresult = (int)result;
78153   return jresult;
78154 }
78155
78156
78157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78158   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78159   Dali::Toolkit::ClampState arg2 ;
78160
78161   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78162   arg2 = (Dali::Toolkit::ClampState)jarg2;
78163   if (arg1) (arg1)->y = arg2;
78164 }
78165
78166
78167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78168   int jresult ;
78169   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78170   Dali::Toolkit::ClampState result;
78171
78172   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78173   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78174   jresult = (int)result;
78175   return jresult;
78176 }
78177
78178
78179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78180   void * jresult ;
78181   Dali::Toolkit::ClampState2D *result = 0 ;
78182
78183   {
78184     try {
78185       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78186     } catch (std::out_of_range& e) {
78187       {
78188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78189       };
78190     } catch (std::exception& e) {
78191       {
78192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78193       };
78194     } catch (Dali::DaliException e) {
78195       {
78196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78197       };
78198     } catch (...) {
78199       {
78200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78201       };
78202     }
78203   }
78204
78205   jresult = (void *)result;
78206   return jresult;
78207 }
78208
78209
78210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78211   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78212
78213   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78214   {
78215     try {
78216       delete arg1;
78217     } catch (std::out_of_range& e) {
78218       {
78219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78220       };
78221     } catch (std::exception& e) {
78222       {
78223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78224       };
78225     } catch (Dali::DaliException e) {
78226       {
78227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78228       };
78229     } catch (...) {
78230       {
78231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78232       };
78233     }
78234   }
78235
78236 }
78237
78238
78239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78240   void * jresult ;
78241   float arg1 ;
78242   float arg2 ;
78243   bool arg3 ;
78244   Dali::Toolkit::RulerDomain *result = 0 ;
78245
78246   arg1 = (float)jarg1;
78247   arg2 = (float)jarg2;
78248   arg3 = jarg3 ? true : false;
78249   {
78250     try {
78251       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78252     } catch (std::out_of_range& e) {
78253       {
78254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78255       };
78256     } catch (std::exception& e) {
78257       {
78258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (Dali::DaliException e) {
78261       {
78262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78263       };
78264     } catch (...) {
78265       {
78266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78267       };
78268     }
78269   }
78270
78271   jresult = (void *)result;
78272   return jresult;
78273 }
78274
78275
78276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78277   void * jresult ;
78278   float arg1 ;
78279   float arg2 ;
78280   Dali::Toolkit::RulerDomain *result = 0 ;
78281
78282   arg1 = (float)jarg1;
78283   arg2 = (float)jarg2;
78284   {
78285     try {
78286       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78287     } catch (std::out_of_range& e) {
78288       {
78289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78290       };
78291     } catch (std::exception& e) {
78292       {
78293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78294       };
78295     } catch (Dali::DaliException e) {
78296       {
78297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78298       };
78299     } catch (...) {
78300       {
78301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78302       };
78303     }
78304   }
78305
78306   jresult = (void *)result;
78307   return jresult;
78308 }
78309
78310
78311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78312   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78313   float arg2 ;
78314
78315   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78316   arg2 = (float)jarg2;
78317   if (arg1) (arg1)->min = arg2;
78318 }
78319
78320
78321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78322   float jresult ;
78323   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78324   float result;
78325
78326   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78327   result = (float) ((arg1)->min);
78328   jresult = result;
78329   return jresult;
78330 }
78331
78332
78333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78334   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78335   float arg2 ;
78336
78337   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78338   arg2 = (float)jarg2;
78339   if (arg1) (arg1)->max = arg2;
78340 }
78341
78342
78343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78344   float jresult ;
78345   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78346   float result;
78347
78348   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78349   result = (float) ((arg1)->max);
78350   jresult = result;
78351   return jresult;
78352 }
78353
78354
78355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78356   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78357   bool arg2 ;
78358
78359   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78360   arg2 = jarg2 ? true : false;
78361   if (arg1) (arg1)->enabled = arg2;
78362 }
78363
78364
78365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78366   unsigned int jresult ;
78367   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78368   bool result;
78369
78370   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78371   result = (bool) ((arg1)->enabled);
78372   jresult = result;
78373   return jresult;
78374 }
78375
78376
78377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78378   float jresult ;
78379   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78380   float arg2 ;
78381   float arg3 ;
78382   float arg4 ;
78383   float result;
78384
78385   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78386   arg2 = (float)jarg2;
78387   arg3 = (float)jarg3;
78388   arg4 = (float)jarg4;
78389   {
78390     try {
78391       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78392     } catch (std::out_of_range& e) {
78393       {
78394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78395       };
78396     } catch (std::exception& e) {
78397       {
78398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78399       };
78400     } catch (Dali::DaliException e) {
78401       {
78402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78403       };
78404     } catch (...) {
78405       {
78406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78407       };
78408     }
78409   }
78410
78411   jresult = result;
78412   return jresult;
78413 }
78414
78415
78416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78417   float jresult ;
78418   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78419   float arg2 ;
78420   float arg3 ;
78421   float result;
78422
78423   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78424   arg2 = (float)jarg2;
78425   arg3 = (float)jarg3;
78426   {
78427     try {
78428       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78429     } catch (std::out_of_range& e) {
78430       {
78431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78432       };
78433     } catch (std::exception& e) {
78434       {
78435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78436       };
78437     } catch (Dali::DaliException e) {
78438       {
78439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78440       };
78441     } catch (...) {
78442       {
78443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78444       };
78445     }
78446   }
78447
78448   jresult = result;
78449   return jresult;
78450 }
78451
78452
78453 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78454   float jresult ;
78455   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78456   float arg2 ;
78457   float result;
78458
78459   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78460   arg2 = (float)jarg2;
78461   {
78462     try {
78463       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78464     } catch (std::out_of_range& e) {
78465       {
78466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78467       };
78468     } catch (std::exception& e) {
78469       {
78470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78471       };
78472     } catch (Dali::DaliException e) {
78473       {
78474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78475       };
78476     } catch (...) {
78477       {
78478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78479       };
78480     }
78481   }
78482
78483   jresult = result;
78484   return jresult;
78485 }
78486
78487
78488 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78489   float jresult ;
78490   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78491   float arg2 ;
78492   float arg3 ;
78493   float arg4 ;
78494   Dali::Toolkit::ClampState *arg5 = 0 ;
78495   float result;
78496
78497   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78498   arg2 = (float)jarg2;
78499   arg3 = (float)jarg3;
78500   arg4 = (float)jarg4;
78501   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78502   if (!arg5) {
78503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78504     return 0;
78505   }
78506   {
78507     try {
78508       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78509     } catch (std::out_of_range& e) {
78510       {
78511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78512       };
78513     } catch (std::exception& e) {
78514       {
78515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78516       };
78517     } catch (Dali::DaliException e) {
78518       {
78519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78520       };
78521     } catch (...) {
78522       {
78523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78524       };
78525     }
78526   }
78527
78528   jresult = result;
78529   return jresult;
78530 }
78531
78532
78533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78534   float jresult ;
78535   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78536   float result;
78537
78538   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78539   {
78540     try {
78541       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78542     } catch (std::out_of_range& e) {
78543       {
78544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78545       };
78546     } catch (std::exception& e) {
78547       {
78548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78549       };
78550     } catch (Dali::DaliException e) {
78551       {
78552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78553       };
78554     } catch (...) {
78555       {
78556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78557       };
78558     }
78559   }
78560
78561   jresult = result;
78562   return jresult;
78563 }
78564
78565
78566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78567   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78568
78569   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78570   {
78571     try {
78572       delete arg1;
78573     } catch (std::out_of_range& e) {
78574       {
78575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78576       };
78577     } catch (std::exception& e) {
78578       {
78579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78580       };
78581     } catch (Dali::DaliException e) {
78582       {
78583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78584       };
78585     } catch (...) {
78586       {
78587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78588       };
78589     }
78590   }
78591
78592 }
78593
78594
78595 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78596   float jresult ;
78597   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78598   float arg2 ;
78599   float arg3 ;
78600   float result;
78601
78602   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78603   arg2 = (float)jarg2;
78604   arg3 = (float)jarg3;
78605   {
78606     try {
78607       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78608     } catch (std::out_of_range& e) {
78609       {
78610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78611       };
78612     } catch (std::exception& e) {
78613       {
78614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78615       };
78616     } catch (Dali::DaliException e) {
78617       {
78618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78619       };
78620     } catch (...) {
78621       {
78622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78623       };
78624     }
78625   }
78626
78627   jresult = result;
78628   return jresult;
78629 }
78630
78631
78632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78633   float jresult ;
78634   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78635   float arg2 ;
78636   float result;
78637
78638   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78639   arg2 = (float)jarg2;
78640   {
78641     try {
78642       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78643     } catch (std::out_of_range& e) {
78644       {
78645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78646       };
78647     } catch (std::exception& e) {
78648       {
78649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78650       };
78651     } catch (Dali::DaliException e) {
78652       {
78653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78654       };
78655     } catch (...) {
78656       {
78657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78658       };
78659     }
78660   }
78661
78662   jresult = result;
78663   return jresult;
78664 }
78665
78666
78667 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78668   float jresult ;
78669   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78670   unsigned int arg2 ;
78671   unsigned int *arg3 = 0 ;
78672   bool arg4 ;
78673   float result;
78674
78675   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78676   arg2 = (unsigned int)jarg2;
78677   arg3 = (unsigned int *)jarg3;
78678   arg4 = jarg4 ? true : false;
78679   {
78680     try {
78681       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78682     } catch (std::out_of_range& e) {
78683       {
78684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78685       };
78686     } catch (std::exception& e) {
78687       {
78688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (Dali::DaliException e) {
78691       {
78692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78693       };
78694     } catch (...) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78697       };
78698     }
78699   }
78700
78701   jresult = result;
78702   return jresult;
78703 }
78704
78705
78706 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78707   unsigned int jresult ;
78708   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78709   float arg2 ;
78710   bool arg3 ;
78711   unsigned int result;
78712
78713   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78714   arg2 = (float)jarg2;
78715   arg3 = jarg3 ? true : false;
78716   {
78717     try {
78718       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78719     } catch (std::out_of_range& e) {
78720       {
78721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78722       };
78723     } catch (std::exception& e) {
78724       {
78725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (Dali::DaliException e) {
78728       {
78729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78730       };
78731     } catch (...) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78734       };
78735     }
78736   }
78737
78738   jresult = result;
78739   return jresult;
78740 }
78741
78742
78743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78744   unsigned int jresult ;
78745   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78746   unsigned int result;
78747
78748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78749   {
78750     try {
78751       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78752     } catch (std::out_of_range& e) {
78753       {
78754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78755       };
78756     } catch (std::exception& e) {
78757       {
78758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78759       };
78760     } catch (Dali::DaliException e) {
78761       {
78762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78763       };
78764     } catch (...) {
78765       {
78766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78767       };
78768     }
78769   }
78770
78771   jresult = result;
78772   return jresult;
78773 }
78774
78775
78776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78777   int jresult ;
78778   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78779   Dali::Toolkit::Ruler::RulerType result;
78780
78781   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78782   {
78783     try {
78784       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78785     } catch (std::out_of_range& e) {
78786       {
78787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78788       };
78789     } catch (std::exception& e) {
78790       {
78791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78792       };
78793     } catch (Dali::DaliException e) {
78794       {
78795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78796       };
78797     } catch (...) {
78798       {
78799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78800       };
78801     }
78802   }
78803
78804   jresult = (int)result;
78805   return jresult;
78806 }
78807
78808
78809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78810   unsigned int jresult ;
78811   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78812   bool result;
78813
78814   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78815   {
78816     try {
78817       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78818     } catch (std::out_of_range& e) {
78819       {
78820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78821       };
78822     } catch (std::exception& e) {
78823       {
78824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78825       };
78826     } catch (Dali::DaliException e) {
78827       {
78828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78829       };
78830     } catch (...) {
78831       {
78832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78833       };
78834     }
78835   }
78836
78837   jresult = result;
78838   return jresult;
78839 }
78840
78841
78842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78843   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78844
78845   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78846   {
78847     try {
78848       (arg1)->Enable();
78849     } catch (std::out_of_range& e) {
78850       {
78851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78852       };
78853     } catch (std::exception& e) {
78854       {
78855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78856       };
78857     } catch (Dali::DaliException e) {
78858       {
78859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78860       };
78861     } catch (...) {
78862       {
78863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78864       };
78865     }
78866   }
78867
78868 }
78869
78870
78871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78872   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78873
78874   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78875   {
78876     try {
78877       (arg1)->Disable();
78878     } catch (std::out_of_range& e) {
78879       {
78880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78881       };
78882     } catch (std::exception& e) {
78883       {
78884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78885       };
78886     } catch (Dali::DaliException e) {
78887       {
78888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78889       };
78890     } catch (...) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78893       };
78894     }
78895   }
78896
78897 }
78898
78899
78900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78901   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78902   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78903   Dali::Toolkit::RulerDomain *argp2 ;
78904
78905   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78906   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78907   if (!argp2) {
78908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78909     return ;
78910   }
78911   arg2 = *argp2;
78912   {
78913     try {
78914       (arg1)->SetDomain(arg2);
78915     } catch (std::out_of_range& e) {
78916       {
78917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78918       };
78919     } catch (std::exception& e) {
78920       {
78921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78922       };
78923     } catch (Dali::DaliException e) {
78924       {
78925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78926       };
78927     } catch (...) {
78928       {
78929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78930       };
78931     }
78932   }
78933
78934 }
78935
78936
78937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78938   void * jresult ;
78939   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78940   Dali::Toolkit::RulerDomain *result = 0 ;
78941
78942   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78943   {
78944     try {
78945       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78946     } catch (std::out_of_range& e) {
78947       {
78948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78949       };
78950     } catch (std::exception& e) {
78951       {
78952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78953       };
78954     } catch (Dali::DaliException e) {
78955       {
78956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78957       };
78958     } catch (...) {
78959       {
78960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78961       };
78962     }
78963   }
78964
78965   jresult = (void *)result;
78966   return jresult;
78967 }
78968
78969
78970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78971   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78972
78973   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78974   {
78975     try {
78976       (arg1)->DisableDomain();
78977     } catch (std::out_of_range& e) {
78978       {
78979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78980       };
78981     } catch (std::exception& e) {
78982       {
78983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78984       };
78985     } catch (Dali::DaliException e) {
78986       {
78987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78988       };
78989     } catch (...) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78992       };
78993     }
78994   }
78995
78996 }
78997
78998
78999 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79000   float jresult ;
79001   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79002   float arg2 ;
79003   float arg3 ;
79004   float arg4 ;
79005   float result;
79006
79007   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79008   arg2 = (float)jarg2;
79009   arg3 = (float)jarg3;
79010   arg4 = (float)jarg4;
79011   {
79012     try {
79013       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79014     } catch (std::out_of_range& e) {
79015       {
79016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79017       };
79018     } catch (std::exception& e) {
79019       {
79020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79021       };
79022     } catch (Dali::DaliException e) {
79023       {
79024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79025       };
79026     } catch (...) {
79027       {
79028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79029       };
79030     }
79031   }
79032
79033   jresult = result;
79034   return jresult;
79035 }
79036
79037
79038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79039   float jresult ;
79040   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79041   float arg2 ;
79042   float arg3 ;
79043   float result;
79044
79045   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79046   arg2 = (float)jarg2;
79047   arg3 = (float)jarg3;
79048   {
79049     try {
79050       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79051     } catch (std::out_of_range& e) {
79052       {
79053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79054       };
79055     } catch (std::exception& e) {
79056       {
79057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79058       };
79059     } catch (Dali::DaliException e) {
79060       {
79061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79062       };
79063     } catch (...) {
79064       {
79065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79066       };
79067     }
79068   }
79069
79070   jresult = result;
79071   return jresult;
79072 }
79073
79074
79075 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79076   float jresult ;
79077   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79078   float arg2 ;
79079   float result;
79080
79081   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79082   arg2 = (float)jarg2;
79083   {
79084     try {
79085       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79086     } catch (std::out_of_range& e) {
79087       {
79088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79089       };
79090     } catch (std::exception& e) {
79091       {
79092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79093       };
79094     } catch (Dali::DaliException e) {
79095       {
79096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79097       };
79098     } catch (...) {
79099       {
79100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79101       };
79102     }
79103   }
79104
79105   jresult = result;
79106   return jresult;
79107 }
79108
79109
79110 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79111   float jresult ;
79112   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79113   float arg2 ;
79114   float arg3 ;
79115   float arg4 ;
79116   Dali::Toolkit::ClampState *arg5 = 0 ;
79117   float result;
79118
79119   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79120   arg2 = (float)jarg2;
79121   arg3 = (float)jarg3;
79122   arg4 = (float)jarg4;
79123   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79124   if (!arg5) {
79125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79126     return 0;
79127   }
79128   {
79129     try {
79130       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79131     } catch (std::out_of_range& e) {
79132       {
79133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79134       };
79135     } catch (std::exception& e) {
79136       {
79137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79138       };
79139     } catch (Dali::DaliException e) {
79140       {
79141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79142       };
79143     } catch (...) {
79144       {
79145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79146       };
79147     }
79148   }
79149
79150   jresult = result;
79151   return jresult;
79152 }
79153
79154
79155 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79156   float jresult ;
79157   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79158   float arg2 ;
79159   float arg3 ;
79160   float arg4 ;
79161   float arg5 ;
79162   float result;
79163
79164   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79165   arg2 = (float)jarg2;
79166   arg3 = (float)jarg3;
79167   arg4 = (float)jarg4;
79168   arg5 = (float)jarg5;
79169   {
79170     try {
79171       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79172     } catch (std::out_of_range& e) {
79173       {
79174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79175       };
79176     } catch (std::exception& e) {
79177       {
79178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79179       };
79180     } catch (Dali::DaliException e) {
79181       {
79182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79183       };
79184     } catch (...) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79187       };
79188     }
79189   }
79190
79191   jresult = result;
79192   return jresult;
79193 }
79194
79195
79196 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79197   float jresult ;
79198   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79199   float arg2 ;
79200   float arg3 ;
79201   float arg4 ;
79202   float result;
79203
79204   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79205   arg2 = (float)jarg2;
79206   arg3 = (float)jarg3;
79207   arg4 = (float)jarg4;
79208   {
79209     try {
79210       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79211     } catch (std::out_of_range& e) {
79212       {
79213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79214       };
79215     } catch (std::exception& e) {
79216       {
79217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79218       };
79219     } catch (Dali::DaliException e) {
79220       {
79221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79222       };
79223     } catch (...) {
79224       {
79225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79226       };
79227     }
79228   }
79229
79230   jresult = result;
79231   return jresult;
79232 }
79233
79234
79235 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79236   float jresult ;
79237   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79238   float arg2 ;
79239   float arg3 ;
79240   float result;
79241
79242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79243   arg2 = (float)jarg2;
79244   arg3 = (float)jarg3;
79245   {
79246     try {
79247       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79248     } catch (std::out_of_range& e) {
79249       {
79250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79251       };
79252     } catch (std::exception& e) {
79253       {
79254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79255       };
79256     } catch (Dali::DaliException e) {
79257       {
79258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79259       };
79260     } catch (...) {
79261       {
79262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79263       };
79264     }
79265   }
79266
79267   jresult = result;
79268   return jresult;
79269 }
79270
79271
79272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79273   float jresult ;
79274   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79275   float arg2 ;
79276   float result;
79277
79278   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79279   arg2 = (float)jarg2;
79280   {
79281     try {
79282       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79283     } catch (std::out_of_range& e) {
79284       {
79285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79286       };
79287     } catch (std::exception& e) {
79288       {
79289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79290       };
79291     } catch (Dali::DaliException e) {
79292       {
79293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79294       };
79295     } catch (...) {
79296       {
79297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79298       };
79299     }
79300   }
79301
79302   jresult = result;
79303   return jresult;
79304 }
79305
79306
79307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79308   float jresult ;
79309   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79310   float arg2 ;
79311   float arg3 ;
79312   float arg4 ;
79313   float arg5 ;
79314   Dali::Toolkit::ClampState *arg6 = 0 ;
79315   float result;
79316
79317   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79318   arg2 = (float)jarg2;
79319   arg3 = (float)jarg3;
79320   arg4 = (float)jarg4;
79321   arg5 = (float)jarg5;
79322   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79323   if (!arg6) {
79324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79325     return 0;
79326   }
79327   {
79328     try {
79329       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79330     } catch (std::out_of_range& e) {
79331       {
79332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79333       };
79334     } catch (std::exception& e) {
79335       {
79336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79337       };
79338     } catch (Dali::DaliException e) {
79339       {
79340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79341       };
79342     } catch (...) {
79343       {
79344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79345       };
79346     }
79347   }
79348
79349   jresult = result;
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79355   void * jresult ;
79356   Dali::Toolkit::DefaultRuler *result = 0 ;
79357
79358   {
79359     try {
79360       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79361     } catch (std::out_of_range& e) {
79362       {
79363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79364       };
79365     } catch (std::exception& e) {
79366       {
79367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79368       };
79369     } catch (Dali::DaliException e) {
79370       {
79371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79372       };
79373     } catch (...) {
79374       {
79375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79376       };
79377     }
79378   }
79379
79380   jresult = (void *)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79386   float jresult ;
79387   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79388   float arg2 ;
79389   float arg3 ;
79390   float result;
79391
79392   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79393   arg2 = (float)jarg2;
79394   arg3 = (float)jarg3;
79395   {
79396     try {
79397       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79398     } catch (std::out_of_range& e) {
79399       {
79400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79401       };
79402     } catch (std::exception& e) {
79403       {
79404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79405       };
79406     } catch (Dali::DaliException e) {
79407       {
79408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79409       };
79410     } catch (...) {
79411       {
79412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79413       };
79414     }
79415   }
79416
79417   jresult = result;
79418   return jresult;
79419 }
79420
79421
79422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79423   float jresult ;
79424   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79425   unsigned int arg2 ;
79426   unsigned int *arg3 = 0 ;
79427   bool arg4 ;
79428   float result;
79429
79430   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79431   arg2 = (unsigned int)jarg2;
79432   arg3 = (unsigned int *)jarg3;
79433   arg4 = jarg4 ? true : false;
79434   {
79435     try {
79436       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79437     } catch (std::out_of_range& e) {
79438       {
79439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79440       };
79441     } catch (std::exception& e) {
79442       {
79443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79444       };
79445     } catch (Dali::DaliException e) {
79446       {
79447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79448       };
79449     } catch (...) {
79450       {
79451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79452       };
79453     }
79454   }
79455
79456   jresult = result;
79457   return jresult;
79458 }
79459
79460
79461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79462   unsigned int jresult ;
79463   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79464   float arg2 ;
79465   bool arg3 ;
79466   unsigned int result;
79467
79468   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79469   arg2 = (float)jarg2;
79470   arg3 = jarg3 ? true : false;
79471   {
79472     try {
79473       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79474     } catch (std::out_of_range& e) {
79475       {
79476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79477       };
79478     } catch (std::exception& e) {
79479       {
79480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79481       };
79482     } catch (Dali::DaliException e) {
79483       {
79484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79485       };
79486     } catch (...) {
79487       {
79488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79489       };
79490     }
79491   }
79492
79493   jresult = result;
79494   return jresult;
79495 }
79496
79497
79498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79499   unsigned int jresult ;
79500   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79501   unsigned int result;
79502
79503   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79504   {
79505     try {
79506       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79507     } catch (std::out_of_range& e) {
79508       {
79509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79510       };
79511     } catch (std::exception& e) {
79512       {
79513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79514       };
79515     } catch (Dali::DaliException e) {
79516       {
79517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79518       };
79519     } catch (...) {
79520       {
79521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79522       };
79523     }
79524   }
79525
79526   jresult = result;
79527   return jresult;
79528 }
79529
79530
79531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79532   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79533
79534   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79535   {
79536     try {
79537       delete arg1;
79538     } catch (std::out_of_range& e) {
79539       {
79540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79541       };
79542     } catch (std::exception& e) {
79543       {
79544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79545       };
79546     } catch (Dali::DaliException e) {
79547       {
79548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79549       };
79550     } catch (...) {
79551       {
79552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79553       };
79554     }
79555   }
79556
79557 }
79558
79559
79560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79561   void * jresult ;
79562   float arg1 ;
79563   Dali::Toolkit::FixedRuler *result = 0 ;
79564
79565   arg1 = (float)jarg1;
79566   {
79567     try {
79568       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79569     } catch (std::out_of_range& e) {
79570       {
79571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79572       };
79573     } catch (std::exception& e) {
79574       {
79575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79576       };
79577     } catch (Dali::DaliException e) {
79578       {
79579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79580       };
79581     } catch (...) {
79582       {
79583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79584       };
79585     }
79586   }
79587
79588   jresult = (void *)result;
79589   return jresult;
79590 }
79591
79592
79593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79594   void * jresult ;
79595   Dali::Toolkit::FixedRuler *result = 0 ;
79596
79597   {
79598     try {
79599       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79600     } catch (std::out_of_range& e) {
79601       {
79602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79603       };
79604     } catch (std::exception& e) {
79605       {
79606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79607       };
79608     } catch (Dali::DaliException e) {
79609       {
79610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79611       };
79612     } catch (...) {
79613       {
79614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79615       };
79616     }
79617   }
79618
79619   jresult = (void *)result;
79620   return jresult;
79621 }
79622
79623
79624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79625   float jresult ;
79626   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79627   float arg2 ;
79628   float arg3 ;
79629   float result;
79630
79631   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79632   arg2 = (float)jarg2;
79633   arg3 = (float)jarg3;
79634   {
79635     try {
79636       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79637     } catch (std::out_of_range& e) {
79638       {
79639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79640       };
79641     } catch (std::exception& e) {
79642       {
79643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (Dali::DaliException e) {
79646       {
79647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79648       };
79649     } catch (...) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79652       };
79653     }
79654   }
79655
79656   jresult = result;
79657   return jresult;
79658 }
79659
79660
79661 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79662   float jresult ;
79663   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79664   unsigned int arg2 ;
79665   unsigned int *arg3 = 0 ;
79666   bool arg4 ;
79667   float result;
79668
79669   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79670   arg2 = (unsigned int)jarg2;
79671   arg3 = (unsigned int *)jarg3;
79672   arg4 = jarg4 ? true : false;
79673   {
79674     try {
79675       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79676     } catch (std::out_of_range& e) {
79677       {
79678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79679       };
79680     } catch (std::exception& e) {
79681       {
79682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79683       };
79684     } catch (Dali::DaliException e) {
79685       {
79686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79687       };
79688     } catch (...) {
79689       {
79690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79691       };
79692     }
79693   }
79694
79695   jresult = result;
79696   return jresult;
79697 }
79698
79699
79700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79701   unsigned int jresult ;
79702   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79703   float arg2 ;
79704   bool arg3 ;
79705   unsigned int result;
79706
79707   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79708   arg2 = (float)jarg2;
79709   arg3 = jarg3 ? true : false;
79710   {
79711     try {
79712       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79713     } catch (std::out_of_range& e) {
79714       {
79715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79716       };
79717     } catch (std::exception& e) {
79718       {
79719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79720       };
79721     } catch (Dali::DaliException e) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79724       };
79725     } catch (...) {
79726       {
79727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79728       };
79729     }
79730   }
79731
79732   jresult = result;
79733   return jresult;
79734 }
79735
79736
79737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79738   unsigned int jresult ;
79739   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79740   unsigned int result;
79741
79742   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79743   {
79744     try {
79745       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79746     } catch (std::out_of_range& e) {
79747       {
79748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79749       };
79750     } catch (std::exception& e) {
79751       {
79752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79753       };
79754     } catch (Dali::DaliException e) {
79755       {
79756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79757       };
79758     } catch (...) {
79759       {
79760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79761       };
79762     }
79763   }
79764
79765   jresult = result;
79766   return jresult;
79767 }
79768
79769
79770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79771   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79772
79773   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79774   {
79775     try {
79776       delete arg1;
79777     } catch (std::out_of_range& e) {
79778       {
79779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79780       };
79781     } catch (std::exception& e) {
79782       {
79783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79784       };
79785     } catch (Dali::DaliException e) {
79786       {
79787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79788       };
79789     } catch (...) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79792       };
79793     }
79794   }
79795
79796 }
79797
79798
79799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79800   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79801   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79802
79803   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79804   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79805   if (arg1) (arg1)->scale = *arg2;
79806 }
79807
79808
79809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79810   void * jresult ;
79811   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79812   Dali::Toolkit::ClampState2D *result = 0 ;
79813
79814   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79815   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79816   jresult = (void *)result;
79817   return jresult;
79818 }
79819
79820
79821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79822   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79823   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79824
79825   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79826   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79827   if (arg1) (arg1)->position = *arg2;
79828 }
79829
79830
79831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79832   void * jresult ;
79833   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79834   Dali::Toolkit::ClampState2D *result = 0 ;
79835
79836   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79837   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79838   jresult = (void *)result;
79839   return jresult;
79840 }
79841
79842
79843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79844   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79845   Dali::Toolkit::ClampState arg2 ;
79846
79847   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79848   arg2 = (Dali::Toolkit::ClampState)jarg2;
79849   if (arg1) (arg1)->rotation = arg2;
79850 }
79851
79852
79853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79854   int jresult ;
79855   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79856   Dali::Toolkit::ClampState result;
79857
79858   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79859   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79860   jresult = (int)result;
79861   return jresult;
79862 }
79863
79864
79865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79866   void * jresult ;
79867   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79868
79869   {
79870     try {
79871       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79872     } catch (std::out_of_range& e) {
79873       {
79874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79875       };
79876     } catch (std::exception& e) {
79877       {
79878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79879       };
79880     } catch (Dali::DaliException e) {
79881       {
79882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79883       };
79884     } catch (...) {
79885       {
79886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79887       };
79888     }
79889   }
79890
79891   jresult = (void *)result;
79892   return jresult;
79893 }
79894
79895
79896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79897   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79898
79899   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79900   {
79901     try {
79902       delete arg1;
79903     } catch (std::out_of_range& e) {
79904       {
79905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79906       };
79907     } catch (std::exception& e) {
79908       {
79909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79910       };
79911     } catch (Dali::DaliException e) {
79912       {
79913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79914       };
79915     } catch (...) {
79916       {
79917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79918       };
79919     }
79920   }
79921
79922 }
79923
79924
79925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79926   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79927   Dali::Toolkit::SnapType arg2 ;
79928
79929   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79930   arg2 = (Dali::Toolkit::SnapType)jarg2;
79931   if (arg1) (arg1)->type = arg2;
79932 }
79933
79934
79935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79936   int jresult ;
79937   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79938   Dali::Toolkit::SnapType result;
79939
79940   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79941   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79942   jresult = (int)result;
79943   return jresult;
79944 }
79945
79946
79947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79948   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79949   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79950
79951   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79952   arg2 = (Dali::Vector2 *)jarg2;
79953   if (arg1) (arg1)->position = *arg2;
79954 }
79955
79956
79957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79958   void * jresult ;
79959   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79960   Dali::Vector2 *result = 0 ;
79961
79962   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79963   result = (Dali::Vector2 *)& ((arg1)->position);
79964   jresult = (void *)result;
79965   return jresult;
79966 }
79967
79968
79969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79970   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79971   float arg2 ;
79972
79973   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79974   arg2 = (float)jarg2;
79975   if (arg1) (arg1)->duration = arg2;
79976 }
79977
79978
79979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79980   float jresult ;
79981   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79982   float result;
79983
79984   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79985   result = (float) ((arg1)->duration);
79986   jresult = result;
79987   return jresult;
79988 }
79989
79990
79991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79992   void * jresult ;
79993   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79994
79995   {
79996     try {
79997       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79998     } catch (std::out_of_range& e) {
79999       {
80000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80001       };
80002     } catch (std::exception& e) {
80003       {
80004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (Dali::DaliException e) {
80007       {
80008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80009       };
80010     } catch (...) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80013       };
80014     }
80015   }
80016
80017   jresult = (void *)result;
80018   return jresult;
80019 }
80020
80021
80022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80023   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80024
80025   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80026   {
80027     try {
80028       delete arg1;
80029     } catch (std::out_of_range& e) {
80030       {
80031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80032       };
80033     } catch (std::exception& e) {
80034       {
80035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80036       };
80037     } catch (Dali::DaliException e) {
80038       {
80039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80040       };
80041     } catch (...) {
80042       {
80043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80044       };
80045     }
80046   }
80047
80048 }
80049
80050
80051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80052   int jresult ;
80053   int result;
80054
80055   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80056   jresult = (int)result;
80057   return jresult;
80058 }
80059
80060
80061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80062   int jresult ;
80063   int result;
80064
80065   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80066   jresult = (int)result;
80067   return jresult;
80068 }
80069
80070
80071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80072   int jresult ;
80073   int result;
80074
80075   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80076   jresult = (int)result;
80077   return jresult;
80078 }
80079
80080
80081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80082   int jresult ;
80083   int result;
80084
80085   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80086   jresult = (int)result;
80087   return jresult;
80088 }
80089
80090
80091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80092   int jresult ;
80093   int result;
80094
80095   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80096   jresult = (int)result;
80097   return jresult;
80098 }
80099
80100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80101   int jresult ;
80102   int result;
80103
80104   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80105   jresult = (int)result;
80106   return jresult;
80107 }
80108
80109
80110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80111   int jresult ;
80112   int result;
80113
80114   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80115   jresult = (int)result;
80116   return jresult;
80117 }
80118
80119
80120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80121   int jresult ;
80122   int result;
80123
80124   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80125   jresult = (int)result;
80126   return jresult;
80127 }
80128
80129
80130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80131   int jresult ;
80132   int result;
80133
80134   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80135   jresult = (int)result;
80136   return jresult;
80137 }
80138
80139
80140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80141   int jresult ;
80142   int result;
80143
80144   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80145   jresult = (int)result;
80146   return jresult;
80147 }
80148
80149
80150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80151   int jresult ;
80152   int result;
80153
80154   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80155   jresult = (int)result;
80156   return jresult;
80157 }
80158
80159
80160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80161   int jresult ;
80162   int result;
80163
80164   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80165   jresult = (int)result;
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80171   int jresult ;
80172   int result;
80173
80174   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80175   jresult = (int)result;
80176   return jresult;
80177 }
80178
80179
80180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80181   int jresult ;
80182   int result;
80183
80184   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80185   jresult = (int)result;
80186   return jresult;
80187 }
80188
80189
80190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80191   int jresult ;
80192   int result;
80193
80194   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80195   jresult = (int)result;
80196   return jresult;
80197 }
80198
80199
80200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80201   int jresult ;
80202   int result;
80203
80204   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80205   jresult = (int)result;
80206   return jresult;
80207 }
80208
80209
80210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80211   int jresult ;
80212   int result;
80213
80214   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80215   jresult = (int)result;
80216   return jresult;
80217 }
80218
80219
80220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80221   int jresult ;
80222   int result;
80223
80224   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80225   jresult = (int)result;
80226   return jresult;
80227 }
80228
80229
80230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80231   int jresult ;
80232   int result;
80233
80234   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80235   jresult = (int)result;
80236   return jresult;
80237 }
80238
80239
80240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80241   int jresult ;
80242   int result;
80243
80244   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80245   jresult = (int)result;
80246   return jresult;
80247 }
80248
80249
80250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80251   int jresult ;
80252   int result;
80253
80254   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80255   jresult = (int)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80261   int jresult ;
80262   int result;
80263
80264   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80265   jresult = (int)result;
80266   return jresult;
80267 }
80268
80269
80270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80271   int jresult ;
80272   int result;
80273
80274   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80275   jresult = (int)result;
80276   return jresult;
80277 }
80278
80279
80280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80281   int jresult ;
80282   int result;
80283
80284   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80285   jresult = (int)result;
80286   return jresult;
80287 }
80288
80289
80290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80291   int jresult ;
80292   int result;
80293
80294   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80295   jresult = (int)result;
80296   return jresult;
80297 }
80298
80299
80300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80301   int jresult ;
80302   int result;
80303
80304   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80305   jresult = (int)result;
80306   return jresult;
80307 }
80308
80309
80310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80311   void * jresult ;
80312   Dali::Toolkit::ScrollView::Property *result = 0 ;
80313
80314   {
80315     try {
80316       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80317     } catch (std::out_of_range& e) {
80318       {
80319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80320       };
80321     } catch (std::exception& e) {
80322       {
80323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80324       };
80325     } catch (Dali::DaliException e) {
80326       {
80327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80328       };
80329     } catch (...) {
80330       {
80331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80332       };
80333     }
80334   }
80335
80336   jresult = (void *)result;
80337   return jresult;
80338 }
80339
80340
80341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80342   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80343
80344   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80345   {
80346     try {
80347       delete arg1;
80348     } catch (std::out_of_range& e) {
80349       {
80350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80351       };
80352     } catch (std::exception& e) {
80353       {
80354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80355       };
80356     } catch (Dali::DaliException e) {
80357       {
80358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80359       };
80360     } catch (...) {
80361       {
80362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80363       };
80364     }
80365   }
80366
80367 }
80368
80369
80370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80371   void * jresult ;
80372   Dali::Toolkit::ScrollView *result = 0 ;
80373
80374   {
80375     try {
80376       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (Dali::DaliException e) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395
80396   jresult = (void *)result;
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80402   void * jresult ;
80403   Dali::Toolkit::ScrollView *arg1 = 0 ;
80404   Dali::Toolkit::ScrollView *result = 0 ;
80405
80406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80407   if (!arg1) {
80408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80409     return 0;
80410   }
80411   {
80412     try {
80413       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80414     } catch (std::out_of_range& e) {
80415       {
80416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80417       };
80418     } catch (std::exception& e) {
80419       {
80420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80421       };
80422     } catch (Dali::DaliException e) {
80423       {
80424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80425       };
80426     } catch (...) {
80427       {
80428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80429       };
80430     }
80431   }
80432
80433   jresult = (void *)result;
80434   return jresult;
80435 }
80436
80437
80438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80439   void * jresult ;
80440   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80441   Dali::Toolkit::ScrollView *arg2 = 0 ;
80442   Dali::Toolkit::ScrollView *result = 0 ;
80443
80444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80445   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80446   if (!arg2) {
80447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80448     return 0;
80449   }
80450   {
80451     try {
80452       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80453     } catch (std::out_of_range& e) {
80454       {
80455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80456       };
80457     } catch (std::exception& e) {
80458       {
80459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80460       };
80461     } catch (Dali::DaliException e) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80464       };
80465     } catch (...) {
80466       {
80467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80468       };
80469     }
80470   }
80471
80472   jresult = (void *)result;
80473   return jresult;
80474 }
80475
80476
80477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80479
80480   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80481   {
80482     try {
80483       delete arg1;
80484     } catch (std::out_of_range& e) {
80485       {
80486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80487       };
80488     } catch (std::exception& e) {
80489       {
80490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80491       };
80492     } catch (Dali::DaliException e) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80495       };
80496     } catch (...) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80499       };
80500     }
80501   }
80502
80503 }
80504
80505
80506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80507   void * jresult ;
80508   Dali::Toolkit::ScrollView result;
80509
80510   {
80511     try {
80512       result = Dali::Toolkit::ScrollView::New();
80513     } catch (std::out_of_range& e) {
80514       {
80515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80516       };
80517     } catch (std::exception& e) {
80518       {
80519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (Dali::DaliException e) {
80522       {
80523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80524       };
80525     } catch (...) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80528       };
80529     }
80530   }
80531
80532   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80533   return jresult;
80534 }
80535
80536
80537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80538   void * jresult ;
80539   Dali::BaseHandle arg1 ;
80540   Dali::BaseHandle *argp1 ;
80541   Dali::Toolkit::ScrollView result;
80542
80543   argp1 = (Dali::BaseHandle *)jarg1;
80544   if (!argp1) {
80545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80546     return 0;
80547   }
80548   arg1 = *argp1;
80549   {
80550     try {
80551       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80552     } catch (std::out_of_range& e) {
80553       {
80554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (std::exception& e) {
80557       {
80558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80559       };
80560     } catch (Dali::DaliException e) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80563       };
80564     } catch (...) {
80565       {
80566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80567       };
80568     }
80569   }
80570
80571   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80572   return jresult;
80573 }
80574
80575
80576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80577   void * jresult ;
80578   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80579   Dali::AlphaFunction result;
80580
80581   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80582   {
80583     try {
80584       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80585     } catch (std::out_of_range& e) {
80586       {
80587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80588       };
80589     } catch (std::exception& e) {
80590       {
80591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80592       };
80593     } catch (Dali::DaliException e) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80596       };
80597     } catch (...) {
80598       {
80599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80600       };
80601     }
80602   }
80603
80604   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80605   return jresult;
80606 }
80607
80608
80609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80610   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80611   Dali::AlphaFunction arg2 ;
80612   Dali::AlphaFunction *argp2 ;
80613
80614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80615   argp2 = (Dali::AlphaFunction *)jarg2;
80616   if (!argp2) {
80617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80618     return ;
80619   }
80620   arg2 = *argp2;
80621   {
80622     try {
80623       (arg1)->SetScrollSnapAlphaFunction(arg2);
80624     } catch (std::out_of_range& e) {
80625       {
80626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80627       };
80628     } catch (std::exception& e) {
80629       {
80630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80631       };
80632     } catch (Dali::DaliException e) {
80633       {
80634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80635       };
80636     } catch (...) {
80637       {
80638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80639       };
80640     }
80641   }
80642
80643 }
80644
80645
80646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80647   void * jresult ;
80648   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80649   Dali::AlphaFunction result;
80650
80651   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80652   {
80653     try {
80654       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80655     } catch (std::out_of_range& e) {
80656       {
80657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80658       };
80659     } catch (std::exception& e) {
80660       {
80661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80662       };
80663     } catch (Dali::DaliException e) {
80664       {
80665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80666       };
80667     } catch (...) {
80668       {
80669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80670       };
80671     }
80672   }
80673
80674   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80675   return jresult;
80676 }
80677
80678
80679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80680   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80681   Dali::AlphaFunction arg2 ;
80682   Dali::AlphaFunction *argp2 ;
80683
80684   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80685   argp2 = (Dali::AlphaFunction *)jarg2;
80686   if (!argp2) {
80687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80688     return ;
80689   }
80690   arg2 = *argp2;
80691   {
80692     try {
80693       (arg1)->SetScrollFlickAlphaFunction(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_GetScrollSnapDuration(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)->GetScrollSnapDuration();
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_SetScrollSnapDuration(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)->SetScrollSnapDuration(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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80781   float jresult ;
80782   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80783   float result;
80784
80785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80786   {
80787     try {
80788       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80789     } catch (std::out_of_range& e) {
80790       {
80791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80792       };
80793     } catch (std::exception& e) {
80794       {
80795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80796       };
80797     } catch (Dali::DaliException e) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80800       };
80801     } catch (...) {
80802       {
80803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80804       };
80805     }
80806   }
80807
80808   jresult = result;
80809   return jresult;
80810 }
80811
80812
80813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80815   float arg2 ;
80816
80817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80818   arg2 = (float)jarg2;
80819   {
80820     try {
80821       (arg1)->SetScrollFlickDuration(arg2);
80822     } catch (std::out_of_range& e) {
80823       {
80824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80825       };
80826     } catch (std::exception& e) {
80827       {
80828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80829       };
80830     } catch (Dali::DaliException e) {
80831       {
80832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80833       };
80834     } catch (...) {
80835       {
80836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80837       };
80838     }
80839   }
80840
80841 }
80842
80843
80844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80846   Dali::Toolkit::RulerPtr arg2 ;
80847   Dali::Toolkit::RulerPtr *argp2 ;
80848
80849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80850   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80851   if (!argp2) {
80852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80853     return ;
80854   }
80855   arg2 = *argp2;
80856   {
80857     try {
80858       (arg1)->SetRulerX(arg2);
80859     } catch (std::out_of_range& e) {
80860       {
80861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80862       };
80863     } catch (std::exception& e) {
80864       {
80865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80866       };
80867     } catch (Dali::DaliException e) {
80868       {
80869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80870       };
80871     } catch (...) {
80872       {
80873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80874       };
80875     }
80876   }
80877
80878 }
80879
80880
80881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80883   Dali::Toolkit::RulerPtr arg2 ;
80884   Dali::Toolkit::RulerPtr *argp2 ;
80885
80886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80887   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80888   if (!argp2) {
80889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80890     return ;
80891   }
80892   arg2 = *argp2;
80893   {
80894     try {
80895       (arg1)->SetRulerY(arg2);
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_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80919   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80920   bool arg2 ;
80921
80922   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80923   arg2 = jarg2 ? true : false;
80924   {
80925     try {
80926       (arg1)->SetScrollSensitive(arg2);
80927     } catch (std::out_of_range& e) {
80928       {
80929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80930       };
80931     } catch (std::exception& e) {
80932       {
80933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80934       };
80935     } catch (Dali::DaliException e) {
80936       {
80937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80938       };
80939     } catch (...) {
80940       {
80941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80942       };
80943     }
80944   }
80945
80946 }
80947
80948
80949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80950   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80951   float arg2 ;
80952   float arg3 ;
80953
80954   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80955   arg2 = (float)jarg2;
80956   arg3 = (float)jarg3;
80957   {
80958     try {
80959       (arg1)->SetMaxOvershoot(arg2,arg3);
80960     } catch (std::out_of_range& e) {
80961       {
80962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80963       };
80964     } catch (std::exception& e) {
80965       {
80966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80967       };
80968     } catch (Dali::DaliException e) {
80969       {
80970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80971       };
80972     } catch (...) {
80973       {
80974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80975       };
80976     }
80977   }
80978
80979 }
80980
80981
80982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80984   Dali::AlphaFunction arg2 ;
80985   Dali::AlphaFunction *argp2 ;
80986
80987   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80988   argp2 = (Dali::AlphaFunction *)jarg2;
80989   if (!argp2) {
80990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80991     return ;
80992   }
80993   arg2 = *argp2;
80994   {
80995     try {
80996       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80997     } catch (std::out_of_range& e) {
80998       {
80999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81000       };
81001     } catch (std::exception& e) {
81002       {
81003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81004       };
81005     } catch (Dali::DaliException e) {
81006       {
81007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81008       };
81009     } catch (...) {
81010       {
81011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81012       };
81013     }
81014   }
81015
81016 }
81017
81018
81019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81020   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81021   float arg2 ;
81022
81023   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81024   arg2 = (float)jarg2;
81025   {
81026     try {
81027       (arg1)->SetSnapOvershootDuration(arg2);
81028     } catch (std::out_of_range& e) {
81029       {
81030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81031       };
81032     } catch (std::exception& e) {
81033       {
81034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81035       };
81036     } catch (Dali::DaliException e) {
81037       {
81038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81039       };
81040     } catch (...) {
81041       {
81042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81043       };
81044     }
81045   }
81046
81047 }
81048
81049
81050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81051   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81052   bool arg2 ;
81053
81054   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81055   arg2 = jarg2 ? true : false;
81056   {
81057     try {
81058       (arg1)->SetActorAutoSnap(arg2);
81059     } catch (std::out_of_range& e) {
81060       {
81061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81062       };
81063     } catch (std::exception& e) {
81064       {
81065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81066       };
81067     } catch (Dali::DaliException e) {
81068       {
81069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81070       };
81071     } catch (...) {
81072       {
81073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81074       };
81075     }
81076   }
81077
81078 }
81079
81080
81081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81083   bool arg2 ;
81084
81085   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81086   arg2 = jarg2 ? true : false;
81087   {
81088     try {
81089       (arg1)->SetWrapMode(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 int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81113   int jresult ;
81114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81115   int result;
81116
81117   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81118   {
81119     try {
81120       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
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_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81146   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81147   int arg2 ;
81148
81149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81150   arg2 = (int)jarg2;
81151   {
81152     try {
81153       (arg1)->SetScrollUpdateDistance(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 unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81177   unsigned int jresult ;
81178   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81179   bool result;
81180
81181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81182   {
81183     try {
81184       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
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_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81210   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81211   bool arg2 ;
81212
81213   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81214   arg2 = jarg2 ? true : false;
81215   {
81216     try {
81217       (arg1)->SetAxisAutoLock(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_GetAxisAutoLockGradient(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)->GetAxisAutoLockGradient();
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_SetAxisAutoLockGradient(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)->SetAxisAutoLockGradient(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_GetFrictionCoefficient(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)->GetFrictionCoefficient();
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_SetFrictionCoefficient(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)->SetFrictionCoefficient(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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81369   float jresult ;
81370   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81371   float result;
81372
81373   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81374   {
81375     try {
81376       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
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 = result;
81397   return jresult;
81398 }
81399
81400
81401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81403   float arg2 ;
81404
81405   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81406   arg2 = (float)jarg2;
81407   {
81408     try {
81409       (arg1)->SetFlickSpeedCoefficient(arg2);
81410     } catch (std::out_of_range& e) {
81411       {
81412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81413       };
81414     } catch (std::exception& e) {
81415       {
81416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81417       };
81418     } catch (Dali::DaliException e) {
81419       {
81420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81421       };
81422     } catch (...) {
81423       {
81424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81425       };
81426     }
81427   }
81428
81429 }
81430
81431
81432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81433   void * jresult ;
81434   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81435   Dali::Vector2 result;
81436
81437   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81438   {
81439     try {
81440       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81441     } catch (std::out_of_range& e) {
81442       {
81443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81444       };
81445     } catch (std::exception& e) {
81446       {
81447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81448       };
81449     } catch (Dali::DaliException e) {
81450       {
81451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81452       };
81453     } catch (...) {
81454       {
81455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81456       };
81457     }
81458   }
81459
81460   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81461   return jresult;
81462 }
81463
81464
81465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81466   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81467   Dali::Vector2 *arg2 = 0 ;
81468
81469   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81470   arg2 = (Dali::Vector2 *)jarg2;
81471   if (!arg2) {
81472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81473     return ;
81474   }
81475   {
81476     try {
81477       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*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_GetMinimumSpeedForFlick(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)->GetMinimumSpeedForFlick();
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_SetMinimumSpeedForFlick(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)->SetMinimumSpeedForFlick(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 float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81565   float jresult ;
81566   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81567   float result;
81568
81569   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81570   {
81571     try {
81572       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
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 = result;
81593   return jresult;
81594 }
81595
81596
81597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81598   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81599   float arg2 ;
81600
81601   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81602   arg2 = (float)jarg2;
81603   {
81604     try {
81605       (arg1)->SetMaxFlickSpeed(arg2);
81606     } catch (std::out_of_range& e) {
81607       {
81608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81609       };
81610     } catch (std::exception& e) {
81611       {
81612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81613       };
81614     } catch (Dali::DaliException e) {
81615       {
81616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81617       };
81618     } catch (...) {
81619       {
81620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81621       };
81622     }
81623   }
81624
81625 }
81626
81627
81628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81629   void * jresult ;
81630   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81631   Dali::Vector2 result;
81632
81633   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81634   {
81635     try {
81636       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81637     } catch (std::out_of_range& e) {
81638       {
81639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81640       };
81641     } catch (std::exception& e) {
81642       {
81643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81644       };
81645     } catch (Dali::DaliException e) {
81646       {
81647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81648       };
81649     } catch (...) {
81650       {
81651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81652       };
81653     }
81654   }
81655
81656   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81657   return jresult;
81658 }
81659
81660
81661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81662   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81663   Dali::Vector2 arg2 ;
81664   Dali::Vector2 *argp2 ;
81665
81666   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81667   argp2 = (Dali::Vector2 *)jarg2;
81668   if (!argp2) {
81669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81670     return ;
81671   }
81672   arg2 = *argp2;
81673   {
81674     try {
81675       (arg1)->SetWheelScrollDistanceStep(arg2);
81676     } catch (std::out_of_range& e) {
81677       {
81678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81679       };
81680     } catch (std::exception& e) {
81681       {
81682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81683       };
81684     } catch (Dali::DaliException e) {
81685       {
81686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81687       };
81688     } catch (...) {
81689       {
81690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81691       };
81692     }
81693   }
81694
81695 }
81696
81697
81698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81699   void * jresult ;
81700   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81701   Dali::Vector2 result;
81702
81703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81704   {
81705     try {
81706       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81707     } catch (std::out_of_range& e) {
81708       {
81709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81710       };
81711     } catch (std::exception& e) {
81712       {
81713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81714       };
81715     } catch (Dali::DaliException e) {
81716       {
81717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81718       };
81719     } catch (...) {
81720       {
81721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81722       };
81723     }
81724   }
81725
81726   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81727   return jresult;
81728 }
81729
81730
81731 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81732   unsigned int jresult ;
81733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81734   unsigned int result;
81735
81736   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81737   {
81738     try {
81739       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81740     } catch (std::out_of_range& e) {
81741       {
81742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81743       };
81744     } catch (std::exception& e) {
81745       {
81746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81747       };
81748     } catch (Dali::DaliException e) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81751       };
81752     } catch (...) {
81753       {
81754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81755       };
81756     }
81757   }
81758
81759   jresult = result;
81760   return jresult;
81761 }
81762
81763
81764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81765   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81766   Dali::Vector2 *arg2 = 0 ;
81767
81768   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81769   arg2 = (Dali::Vector2 *)jarg2;
81770   if (!arg2) {
81771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81772     return ;
81773   }
81774   {
81775     try {
81776       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81777     } catch (std::out_of_range& e) {
81778       {
81779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81780       };
81781     } catch (std::exception& e) {
81782       {
81783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81784       };
81785     } catch (Dali::DaliException e) {
81786       {
81787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81788       };
81789     } catch (...) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81792       };
81793     }
81794   }
81795
81796 }
81797
81798
81799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81800   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81801   Dali::Vector2 *arg2 = 0 ;
81802   float arg3 ;
81803
81804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81805   arg2 = (Dali::Vector2 *)jarg2;
81806   if (!arg2) {
81807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81808     return ;
81809   }
81810   arg3 = (float)jarg3;
81811   {
81812     try {
81813       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81814     } catch (std::out_of_range& e) {
81815       {
81816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81817       };
81818     } catch (std::exception& e) {
81819       {
81820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81821       };
81822     } catch (Dali::DaliException e) {
81823       {
81824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81825       };
81826     } catch (...) {
81827       {
81828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81829       };
81830     }
81831   }
81832
81833 }
81834
81835
81836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81838   Dali::Vector2 *arg2 = 0 ;
81839   float arg3 ;
81840   Dali::AlphaFunction arg4 ;
81841   Dali::AlphaFunction *argp4 ;
81842
81843   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81844   arg2 = (Dali::Vector2 *)jarg2;
81845   if (!arg2) {
81846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81847     return ;
81848   }
81849   arg3 = (float)jarg3;
81850   argp4 = (Dali::AlphaFunction *)jarg4;
81851   if (!argp4) {
81852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81853     return ;
81854   }
81855   arg4 = *argp4;
81856   {
81857     try {
81858       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81859     } catch (std::out_of_range& e) {
81860       {
81861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81862       };
81863     } catch (std::exception& e) {
81864       {
81865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81866       };
81867     } catch (Dali::DaliException e) {
81868       {
81869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81870       };
81871     } catch (...) {
81872       {
81873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81874       };
81875     }
81876   }
81877
81878 }
81879
81880
81881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81882   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81883   Dali::Vector2 *arg2 = 0 ;
81884   float arg3 ;
81885   Dali::Toolkit::DirectionBias arg4 ;
81886   Dali::Toolkit::DirectionBias arg5 ;
81887
81888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81889   arg2 = (Dali::Vector2 *)jarg2;
81890   if (!arg2) {
81891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81892     return ;
81893   }
81894   arg3 = (float)jarg3;
81895   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81896   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81897   {
81898     try {
81899       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81900     } catch (std::out_of_range& e) {
81901       {
81902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81903       };
81904     } catch (std::exception& e) {
81905       {
81906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81907       };
81908     } catch (Dali::DaliException e) {
81909       {
81910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81911       };
81912     } catch (...) {
81913       {
81914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81915       };
81916     }
81917   }
81918
81919 }
81920
81921
81922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81923   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81924   Dali::Vector2 *arg2 = 0 ;
81925   float arg3 ;
81926   Dali::AlphaFunction arg4 ;
81927   Dali::Toolkit::DirectionBias arg5 ;
81928   Dali::Toolkit::DirectionBias arg6 ;
81929   Dali::AlphaFunction *argp4 ;
81930
81931   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81932   arg2 = (Dali::Vector2 *)jarg2;
81933   if (!arg2) {
81934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81935     return ;
81936   }
81937   arg3 = (float)jarg3;
81938   argp4 = (Dali::AlphaFunction *)jarg4;
81939   if (!argp4) {
81940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81941     return ;
81942   }
81943   arg4 = *argp4;
81944   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81945   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81946   {
81947     try {
81948       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
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_5(void * jarg1, unsigned int jarg2) {
81972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81973   unsigned int arg2 ;
81974
81975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81976   arg2 = (unsigned int)jarg2;
81977   {
81978     try {
81979       (arg1)->ScrollTo(arg2);
81980     } catch (std::out_of_range& e) {
81981       {
81982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81983       };
81984     } catch (std::exception& e) {
81985       {
81986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81987       };
81988     } catch (Dali::DaliException e) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81991       };
81992     } catch (...) {
81993       {
81994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81995       };
81996     }
81997   }
81998
81999 }
82000
82001
82002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82003   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82004   unsigned int arg2 ;
82005   float arg3 ;
82006
82007   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82008   arg2 = (unsigned int)jarg2;
82009   arg3 = (float)jarg3;
82010   {
82011     try {
82012       (arg1)->ScrollTo(arg2,arg3);
82013     } catch (std::out_of_range& e) {
82014       {
82015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82016       };
82017     } catch (std::exception& e) {
82018       {
82019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82020       };
82021     } catch (Dali::DaliException e) {
82022       {
82023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82024       };
82025     } catch (...) {
82026       {
82027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82028       };
82029     }
82030   }
82031
82032 }
82033
82034
82035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82036   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82037   unsigned int arg2 ;
82038   float arg3 ;
82039   Dali::Toolkit::DirectionBias arg4 ;
82040
82041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82042   arg2 = (unsigned int)jarg2;
82043   arg3 = (float)jarg3;
82044   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82045   {
82046     try {
82047       (arg1)->ScrollTo(arg2,arg3,arg4);
82048     } catch (std::out_of_range& e) {
82049       {
82050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82051       };
82052     } catch (std::exception& e) {
82053       {
82054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82055       };
82056     } catch (Dali::DaliException e) {
82057       {
82058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82059       };
82060     } catch (...) {
82061       {
82062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82063       };
82064     }
82065   }
82066
82067 }
82068
82069
82070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82071   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82072   Dali::Actor *arg2 = 0 ;
82073
82074   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82075   arg2 = (Dali::Actor *)jarg2;
82076   if (!arg2) {
82077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82078     return ;
82079   }
82080   {
82081     try {
82082       (arg1)->ScrollTo(*arg2);
82083     } catch (std::out_of_range& e) {
82084       {
82085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82086       };
82087     } catch (std::exception& e) {
82088       {
82089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82090       };
82091     } catch (Dali::DaliException e) {
82092       {
82093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82094       };
82095     } catch (...) {
82096       {
82097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82098       };
82099     }
82100   }
82101
82102 }
82103
82104
82105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82107   Dali::Actor *arg2 = 0 ;
82108   float arg3 ;
82109
82110   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82111   arg2 = (Dali::Actor *)jarg2;
82112   if (!arg2) {
82113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82114     return ;
82115   }
82116   arg3 = (float)jarg3;
82117   {
82118     try {
82119       (arg1)->ScrollTo(*arg2,arg3);
82120     } catch (std::out_of_range& e) {
82121       {
82122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82123       };
82124     } catch (std::exception& e) {
82125       {
82126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82127       };
82128     } catch (Dali::DaliException e) {
82129       {
82130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82131       };
82132     } catch (...) {
82133       {
82134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82135       };
82136     }
82137   }
82138
82139 }
82140
82141
82142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82143   unsigned int jresult ;
82144   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82145   bool result;
82146
82147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82148   {
82149     try {
82150       result = (bool)(arg1)->ScrollToSnapPoint();
82151     } catch (std::out_of_range& e) {
82152       {
82153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82154       };
82155     } catch (std::exception& e) {
82156       {
82157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82158       };
82159     } catch (Dali::DaliException e) {
82160       {
82161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82162       };
82163     } catch (...) {
82164       {
82165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82166       };
82167     }
82168   }
82169
82170   jresult = result;
82171   return jresult;
82172 }
82173
82174
82175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82176   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82177   Dali::Constraint arg2 ;
82178   Dali::Constraint *argp2 ;
82179
82180   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82181   argp2 = (Dali::Constraint *)jarg2;
82182   if (!argp2) {
82183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82184     return ;
82185   }
82186   arg2 = *argp2;
82187   {
82188     try {
82189       (arg1)->ApplyConstraintToChildren(arg2);
82190     } catch (std::out_of_range& e) {
82191       {
82192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82193       };
82194     } catch (std::exception& e) {
82195       {
82196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82197       };
82198     } catch (Dali::DaliException e) {
82199       {
82200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82201       };
82202     } catch (...) {
82203       {
82204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82205       };
82206     }
82207   }
82208
82209 }
82210
82211
82212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82213   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82214
82215   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82216   {
82217     try {
82218       (arg1)->RemoveConstraintsFromChildren();
82219     } catch (std::out_of_range& e) {
82220       {
82221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82222       };
82223     } catch (std::exception& e) {
82224       {
82225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82226       };
82227     } catch (Dali::DaliException e) {
82228       {
82229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82230       };
82231     } catch (...) {
82232       {
82233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82234       };
82235     }
82236   }
82237
82238 }
82239
82240
82241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82242   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82243   Dali::Toolkit::ScrollViewEffect arg2 ;
82244   Dali::Toolkit::ScrollViewEffect *argp2 ;
82245
82246   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82247   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82248   if (!argp2) {
82249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82250     return ;
82251   }
82252   arg2 = *argp2;
82253   {
82254     try {
82255       (arg1)->ApplyEffect(arg2);
82256     } catch (std::out_of_range& e) {
82257       {
82258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82259       };
82260     } catch (std::exception& e) {
82261       {
82262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82263       };
82264     } catch (Dali::DaliException e) {
82265       {
82266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82267       };
82268     } catch (...) {
82269       {
82270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82271       };
82272     }
82273   }
82274
82275 }
82276
82277
82278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82279   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82280   Dali::Toolkit::ScrollViewEffect arg2 ;
82281   Dali::Toolkit::ScrollViewEffect *argp2 ;
82282
82283   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82284   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82285   if (!argp2) {
82286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82287     return ;
82288   }
82289   arg2 = *argp2;
82290   {
82291     try {
82292       (arg1)->RemoveEffect(arg2);
82293     } catch (std::out_of_range& e) {
82294       {
82295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82296       };
82297     } catch (std::exception& e) {
82298       {
82299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82300       };
82301     } catch (Dali::DaliException e) {
82302       {
82303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82304       };
82305     } catch (...) {
82306       {
82307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82308       };
82309     }
82310   }
82311
82312 }
82313
82314
82315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82316   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82317
82318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82319   {
82320     try {
82321       (arg1)->RemoveAllEffects();
82322     } catch (std::out_of_range& e) {
82323       {
82324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82325       };
82326     } catch (std::exception& e) {
82327       {
82328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82329       };
82330     } catch (Dali::DaliException e) {
82331       {
82332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82333       };
82334     } catch (...) {
82335       {
82336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82337       };
82338     }
82339   }
82340
82341 }
82342
82343
82344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82346   Dali::Actor arg2 ;
82347   Dali::Actor *argp2 ;
82348
82349   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82350   argp2 = (Dali::Actor *)jarg2;
82351   if (!argp2) {
82352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82353     return ;
82354   }
82355   arg2 = *argp2;
82356   {
82357     try {
82358       (arg1)->BindActor(arg2);
82359     } catch (std::out_of_range& e) {
82360       {
82361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82362       };
82363     } catch (std::exception& e) {
82364       {
82365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82366       };
82367     } catch (Dali::DaliException e) {
82368       {
82369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82370       };
82371     } catch (...) {
82372       {
82373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82374       };
82375     }
82376   }
82377
82378 }
82379
82380
82381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82383   Dali::Actor arg2 ;
82384   Dali::Actor *argp2 ;
82385
82386   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82387   argp2 = (Dali::Actor *)jarg2;
82388   if (!argp2) {
82389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82390     return ;
82391   }
82392   arg2 = *argp2;
82393   {
82394     try {
82395       (arg1)->UnbindActor(arg2);
82396     } catch (std::out_of_range& e) {
82397       {
82398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82399       };
82400     } catch (std::exception& e) {
82401       {
82402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82403       };
82404     } catch (Dali::DaliException e) {
82405       {
82406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82407       };
82408     } catch (...) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82411       };
82412     }
82413   }
82414
82415 }
82416
82417
82418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82419   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82420   Dali::Radian arg2 ;
82421   Dali::Radian arg3 ;
82422   Dali::Radian *argp2 ;
82423   Dali::Radian *argp3 ;
82424
82425   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82426   argp2 = (Dali::Radian *)jarg2;
82427   if (!argp2) {
82428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82429     return ;
82430   }
82431   arg2 = *argp2;
82432   argp3 = (Dali::Radian *)jarg3;
82433   if (!argp3) {
82434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82435     return ;
82436   }
82437   arg3 = *argp3;
82438   {
82439     try {
82440       (arg1)->SetScrollingDirection(arg2,arg3);
82441     } catch (std::out_of_range& e) {
82442       {
82443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82444       };
82445     } catch (std::exception& e) {
82446       {
82447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82448       };
82449     } catch (Dali::DaliException e) {
82450       {
82451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82452       };
82453     } catch (...) {
82454       {
82455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82456       };
82457     }
82458   }
82459
82460 }
82461
82462
82463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82464   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82465   Dali::Radian arg2 ;
82466   Dali::Radian *argp2 ;
82467
82468   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82469   argp2 = (Dali::Radian *)jarg2;
82470   if (!argp2) {
82471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82472     return ;
82473   }
82474   arg2 = *argp2;
82475   {
82476     try {
82477       (arg1)->SetScrollingDirection(arg2);
82478     } catch (std::out_of_range& e) {
82479       {
82480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82481       };
82482     } catch (std::exception& e) {
82483       {
82484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82485       };
82486     } catch (Dali::DaliException e) {
82487       {
82488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82489       };
82490     } catch (...) {
82491       {
82492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82493       };
82494     }
82495   }
82496
82497 }
82498
82499
82500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82502   Dali::Radian arg2 ;
82503   Dali::Radian *argp2 ;
82504
82505   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82506   argp2 = (Dali::Radian *)jarg2;
82507   if (!argp2) {
82508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82509     return ;
82510   }
82511   arg2 = *argp2;
82512   {
82513     try {
82514       (arg1)->RemoveScrollingDirection(arg2);
82515     } catch (std::out_of_range& e) {
82516       {
82517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82518       };
82519     } catch (std::exception& e) {
82520       {
82521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82522       };
82523     } catch (Dali::DaliException e) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82526       };
82527     } catch (...) {
82528       {
82529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82530       };
82531     }
82532   }
82533
82534 }
82535
82536
82537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82538   void * jresult ;
82539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82540   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82541
82542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82543   {
82544     try {
82545       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82546     } catch (std::out_of_range& e) {
82547       {
82548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82549       };
82550     } catch (std::exception& e) {
82551       {
82552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82553       };
82554     } catch (Dali::DaliException e) {
82555       {
82556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82557       };
82558     } catch (...) {
82559       {
82560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82561       };
82562     }
82563   }
82564
82565   jresult = (void *)result;
82566   return jresult;
82567 }
82568
82569
82570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82571   int jresult ;
82572   int result;
82573
82574   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82575   jresult = (int)result;
82576   return jresult;
82577 }
82578
82579
82580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82581   int jresult ;
82582   int result;
82583
82584   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82585   jresult = (int)result;
82586   return jresult;
82587 }
82588
82589
82590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82591   int jresult ;
82592   int result;
82593
82594   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82595   jresult = (int)result;
82596   return jresult;
82597 }
82598
82599
82600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82601   int jresult ;
82602   int result;
82603
82604   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82605   jresult = (int)result;
82606   return jresult;
82607 }
82608
82609
82610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82611   int jresult ;
82612   int result;
82613
82614   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82615   jresult = (int)result;
82616   return jresult;
82617 }
82618
82619
82620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82621   void * jresult ;
82622   Dali::Toolkit::TableView::Property *result = 0 ;
82623
82624   {
82625     try {
82626       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82627     } catch (std::out_of_range& e) {
82628       {
82629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82630       };
82631     } catch (std::exception& e) {
82632       {
82633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (Dali::DaliException e) {
82636       {
82637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82638       };
82639     } catch (...) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82642       };
82643     }
82644   }
82645
82646   jresult = (void *)result;
82647   return jresult;
82648 }
82649
82650
82651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82652   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82653
82654   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82655   {
82656     try {
82657       delete arg1;
82658     } catch (std::out_of_range& e) {
82659       {
82660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82661       };
82662     } catch (std::exception& e) {
82663       {
82664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82665       };
82666     } catch (Dali::DaliException e) {
82667       {
82668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82669       };
82670     } catch (...) {
82671       {
82672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82673       };
82674     }
82675   }
82676
82677 }
82678
82679
82680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82681   int jresult ;
82682   int result;
82683
82684   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82685   jresult = (int)result;
82686   return jresult;
82687 }
82688
82689
82690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82691   int jresult ;
82692   int result;
82693
82694   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82695   jresult = (int)result;
82696   return jresult;
82697 }
82698
82699
82700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82701   int jresult ;
82702   int result;
82703
82704   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82705   jresult = (int)result;
82706   return jresult;
82707 }
82708
82709
82710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82711   int jresult ;
82712   int result;
82713
82714   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82715   jresult = (int)result;
82716   return jresult;
82717 }
82718
82719
82720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82721   int jresult ;
82722   int result;
82723
82724   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82725   jresult = (int)result;
82726   return jresult;
82727 }
82728
82729
82730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82731   void * jresult ;
82732   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82733
82734   {
82735     try {
82736       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82737     } catch (std::out_of_range& e) {
82738       {
82739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82740       };
82741     } catch (std::exception& e) {
82742       {
82743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82744       };
82745     } catch (Dali::DaliException e) {
82746       {
82747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82748       };
82749     } catch (...) {
82750       {
82751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82752       };
82753     }
82754   }
82755
82756   jresult = (void *)result;
82757   return jresult;
82758 }
82759
82760
82761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82762   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82763
82764   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82765   {
82766     try {
82767       delete arg1;
82768     } catch (std::out_of_range& e) {
82769       {
82770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82771       };
82772     } catch (std::exception& e) {
82773       {
82774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82775       };
82776     } catch (Dali::DaliException e) {
82777       {
82778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82779       };
82780     } catch (...) {
82781       {
82782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82783       };
82784     }
82785   }
82786
82787 }
82788
82789
82790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82791   void * jresult ;
82792   unsigned int arg1 ;
82793   unsigned int arg2 ;
82794   unsigned int arg3 ;
82795   unsigned int arg4 ;
82796   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82797
82798   arg1 = (unsigned int)jarg1;
82799   arg2 = (unsigned int)jarg2;
82800   arg3 = (unsigned int)jarg3;
82801   arg4 = (unsigned int)jarg4;
82802   {
82803     try {
82804       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82805     } catch (std::out_of_range& e) {
82806       {
82807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82808       };
82809     } catch (std::exception& e) {
82810       {
82811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82812       };
82813     } catch (Dali::DaliException e) {
82814       {
82815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82816       };
82817     } catch (...) {
82818       {
82819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82820       };
82821     }
82822   }
82823
82824   jresult = (void *)result;
82825   return jresult;
82826 }
82827
82828
82829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82830   void * jresult ;
82831   unsigned int arg1 ;
82832   unsigned int arg2 ;
82833   unsigned int arg3 ;
82834   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82835
82836   arg1 = (unsigned int)jarg1;
82837   arg2 = (unsigned int)jarg2;
82838   arg3 = (unsigned int)jarg3;
82839   {
82840     try {
82841       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82842     } catch (std::out_of_range& e) {
82843       {
82844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82845       };
82846     } catch (std::exception& e) {
82847       {
82848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82849       };
82850     } catch (Dali::DaliException e) {
82851       {
82852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82853       };
82854     } catch (...) {
82855       {
82856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82857       };
82858     }
82859   }
82860
82861   jresult = (void *)result;
82862   return jresult;
82863 }
82864
82865
82866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82867   void * jresult ;
82868   unsigned int arg1 ;
82869   unsigned int arg2 ;
82870   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82871
82872   arg1 = (unsigned int)jarg1;
82873   arg2 = (unsigned int)jarg2;
82874   {
82875     try {
82876       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
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_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82902   void * jresult ;
82903   unsigned int arg1 ;
82904   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82905
82906   arg1 = (unsigned int)jarg1;
82907   {
82908     try {
82909       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82910     } catch (std::out_of_range& e) {
82911       {
82912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82913       };
82914     } catch (std::exception& e) {
82915       {
82916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82917       };
82918     } catch (Dali::DaliException e) {
82919       {
82920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82921       };
82922     } catch (...) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82925       };
82926     }
82927   }
82928
82929   jresult = (void *)result;
82930   return jresult;
82931 }
82932
82933
82934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82935   void * jresult ;
82936   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82937
82938   {
82939     try {
82940       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82941     } catch (std::out_of_range& e) {
82942       {
82943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82944       };
82945     } catch (std::exception& e) {
82946       {
82947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82948       };
82949     } catch (Dali::DaliException e) {
82950       {
82951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82952       };
82953     } catch (...) {
82954       {
82955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82956       };
82957     }
82958   }
82959
82960   jresult = (void *)result;
82961   return jresult;
82962 }
82963
82964
82965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82966   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82967   unsigned int arg2 ;
82968
82969   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82970   arg2 = (unsigned int)jarg2;
82971   if (arg1) (arg1)->rowIndex = arg2;
82972 }
82973
82974
82975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82976   unsigned int jresult ;
82977   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82978   unsigned int result;
82979
82980   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82981   result = (unsigned int) ((arg1)->rowIndex);
82982   jresult = result;
82983   return jresult;
82984 }
82985
82986
82987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82988   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82989   unsigned int arg2 ;
82990
82991   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82992   arg2 = (unsigned int)jarg2;
82993   if (arg1) (arg1)->columnIndex = arg2;
82994 }
82995
82996
82997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82998   unsigned int jresult ;
82999   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83000   unsigned int result;
83001
83002   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83003   result = (unsigned int) ((arg1)->columnIndex);
83004   jresult = result;
83005   return jresult;
83006 }
83007
83008
83009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83010   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83011   unsigned int arg2 ;
83012
83013   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83014   arg2 = (unsigned int)jarg2;
83015   if (arg1) (arg1)->rowSpan = arg2;
83016 }
83017
83018
83019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83020   unsigned int jresult ;
83021   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83022   unsigned int result;
83023
83024   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83025   result = (unsigned int) ((arg1)->rowSpan);
83026   jresult = result;
83027   return jresult;
83028 }
83029
83030
83031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83032   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83033   unsigned int arg2 ;
83034
83035   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83036   arg2 = (unsigned int)jarg2;
83037   if (arg1) (arg1)->columnSpan = arg2;
83038 }
83039
83040
83041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83042   unsigned int jresult ;
83043   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83044   unsigned int result;
83045
83046   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83047   result = (unsigned int) ((arg1)->columnSpan);
83048   jresult = result;
83049   return jresult;
83050 }
83051
83052
83053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83054   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83055
83056   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83057   {
83058     try {
83059       delete arg1;
83060     } catch (std::out_of_range& e) {
83061       {
83062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83063       };
83064     } catch (std::exception& e) {
83065       {
83066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83067       };
83068     } catch (Dali::DaliException e) {
83069       {
83070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83075       };
83076     }
83077   }
83078
83079 }
83080
83081
83082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83083   void * jresult ;
83084   Dali::Toolkit::TableView *result = 0 ;
83085
83086   {
83087     try {
83088       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83089     } catch (std::out_of_range& e) {
83090       {
83091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83092       };
83093     } catch (std::exception& e) {
83094       {
83095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (Dali::DaliException e) {
83098       {
83099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83100       };
83101     } catch (...) {
83102       {
83103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83104       };
83105     }
83106   }
83107
83108   jresult = (void *)result;
83109   return jresult;
83110 }
83111
83112
83113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83114   void * jresult ;
83115   Dali::Toolkit::TableView *arg1 = 0 ;
83116   Dali::Toolkit::TableView *result = 0 ;
83117
83118   arg1 = (Dali::Toolkit::TableView *)jarg1;
83119   if (!arg1) {
83120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83121     return 0;
83122   }
83123   {
83124     try {
83125       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83126     } catch (std::out_of_range& e) {
83127       {
83128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83129       };
83130     } catch (std::exception& e) {
83131       {
83132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83133       };
83134     } catch (Dali::DaliException e) {
83135       {
83136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83137       };
83138     } catch (...) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83141       };
83142     }
83143   }
83144
83145   jresult = (void *)result;
83146   return jresult;
83147 }
83148
83149
83150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83151   void * jresult ;
83152   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83153   Dali::Toolkit::TableView *arg2 = 0 ;
83154   Dali::Toolkit::TableView *result = 0 ;
83155
83156   arg1 = (Dali::Toolkit::TableView *)jarg1;
83157   arg2 = (Dali::Toolkit::TableView *)jarg2;
83158   if (!arg2) {
83159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83160     return 0;
83161   }
83162   {
83163     try {
83164       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*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 = (void *)result;
83185   return jresult;
83186 }
83187
83188
83189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83190   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83191
83192   arg1 = (Dali::Toolkit::TableView *)jarg1;
83193   {
83194     try {
83195       delete arg1;
83196     } catch (std::out_of_range& e) {
83197       {
83198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83199       };
83200     } catch (std::exception& e) {
83201       {
83202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83203       };
83204     } catch (Dali::DaliException e) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83207       };
83208     } catch (...) {
83209       {
83210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83211       };
83212     }
83213   }
83214
83215 }
83216
83217
83218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83219   void * jresult ;
83220   unsigned int arg1 ;
83221   unsigned int arg2 ;
83222   Dali::Toolkit::TableView result;
83223
83224   arg1 = (unsigned int)jarg1;
83225   arg2 = (unsigned int)jarg2;
83226   {
83227     try {
83228       result = Dali::Toolkit::TableView::New(arg1,arg2);
83229     } catch (std::out_of_range& e) {
83230       {
83231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83232       };
83233     } catch (std::exception& e) {
83234       {
83235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83236       };
83237     } catch (Dali::DaliException e) {
83238       {
83239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83240       };
83241     } catch (...) {
83242       {
83243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83244       };
83245     }
83246   }
83247
83248   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83249   return jresult;
83250 }
83251
83252
83253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83254   void * jresult ;
83255   Dali::BaseHandle arg1 ;
83256   Dali::BaseHandle *argp1 ;
83257   Dali::Toolkit::TableView result;
83258
83259   argp1 = (Dali::BaseHandle *)jarg1;
83260   if (!argp1) {
83261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83262     return 0;
83263   }
83264   arg1 = *argp1;
83265   {
83266     try {
83267       result = Dali::Toolkit::TableView::DownCast(arg1);
83268     } catch (std::out_of_range& e) {
83269       {
83270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83271       };
83272     } catch (std::exception& e) {
83273       {
83274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83275       };
83276     } catch (Dali::DaliException e) {
83277       {
83278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83279       };
83280     } catch (...) {
83281       {
83282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83283       };
83284     }
83285   }
83286
83287   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83288   return jresult;
83289 }
83290
83291
83292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83293   unsigned int jresult ;
83294   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83295   Dali::Actor arg2 ;
83296   Dali::Toolkit::TableView::CellPosition arg3 ;
83297   Dali::Actor *argp2 ;
83298   Dali::Toolkit::TableView::CellPosition *argp3 ;
83299   bool result;
83300
83301   arg1 = (Dali::Toolkit::TableView *)jarg1;
83302   argp2 = (Dali::Actor *)jarg2;
83303   if (!argp2) {
83304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83305     return 0;
83306   }
83307   arg2 = *argp2;
83308   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83309   if (!argp3) {
83310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83311     return 0;
83312   }
83313   arg3 = *argp3;
83314   {
83315     try {
83316       result = (bool)(arg1)->AddChild(arg2,arg3);
83317     } catch (std::out_of_range& e) {
83318       {
83319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83320       };
83321     } catch (std::exception& e) {
83322       {
83323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83324       };
83325     } catch (Dali::DaliException e) {
83326       {
83327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83328       };
83329     } catch (...) {
83330       {
83331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83332       };
83333     }
83334   }
83335
83336   jresult = result;
83337   return jresult;
83338 }
83339
83340
83341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83342   void * jresult ;
83343   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83344   Dali::Toolkit::TableView::CellPosition arg2 ;
83345   Dali::Toolkit::TableView::CellPosition *argp2 ;
83346   Dali::Actor result;
83347
83348   arg1 = (Dali::Toolkit::TableView *)jarg1;
83349   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83350   if (!argp2) {
83351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83352     return 0;
83353   }
83354   arg2 = *argp2;
83355   {
83356     try {
83357       result = (arg1)->GetChildAt(arg2);
83358     } catch (std::out_of_range& e) {
83359       {
83360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83361       };
83362     } catch (std::exception& e) {
83363       {
83364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83365       };
83366     } catch (Dali::DaliException e) {
83367       {
83368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83369       };
83370     } catch (...) {
83371       {
83372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83373       };
83374     }
83375   }
83376
83377   jresult = new Dali::Actor((const Dali::Actor &)result);
83378   return jresult;
83379 }
83380
83381
83382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83383   void * jresult ;
83384   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83385   Dali::Toolkit::TableView::CellPosition arg2 ;
83386   Dali::Toolkit::TableView::CellPosition *argp2 ;
83387   Dali::Actor result;
83388
83389   arg1 = (Dali::Toolkit::TableView *)jarg1;
83390   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83391   if (!argp2) {
83392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83393     return 0;
83394   }
83395   arg2 = *argp2;
83396   {
83397     try {
83398       result = (arg1)->RemoveChildAt(arg2);
83399     } catch (std::out_of_range& e) {
83400       {
83401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83402       };
83403     } catch (std::exception& e) {
83404       {
83405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83406       };
83407     } catch (Dali::DaliException e) {
83408       {
83409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83410       };
83411     } catch (...) {
83412       {
83413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83414       };
83415     }
83416   }
83417
83418   jresult = new Dali::Actor((const Dali::Actor &)result);
83419   return jresult;
83420 }
83421
83422
83423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83424   unsigned int jresult ;
83425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83426   Dali::Actor arg2 ;
83427   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83428   Dali::Actor *argp2 ;
83429   bool result;
83430
83431   arg1 = (Dali::Toolkit::TableView *)jarg1;
83432   argp2 = (Dali::Actor *)jarg2;
83433   if (!argp2) {
83434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83435     return 0;
83436   }
83437   arg2 = *argp2;
83438   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83439   if (!arg3) {
83440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83441     return 0;
83442   }
83443   {
83444     try {
83445       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83446     } catch (std::out_of_range& e) {
83447       {
83448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83449       };
83450     } catch (std::exception& e) {
83451       {
83452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83453       };
83454     } catch (Dali::DaliException e) {
83455       {
83456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83457       };
83458     } catch (...) {
83459       {
83460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83461       };
83462     }
83463   }
83464
83465   jresult = result;
83466   return jresult;
83467 }
83468
83469
83470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83472   unsigned int arg2 ;
83473
83474   arg1 = (Dali::Toolkit::TableView *)jarg1;
83475   arg2 = (unsigned int)jarg2;
83476   {
83477     try {
83478       (arg1)->InsertRow(arg2);
83479     } catch (std::out_of_range& e) {
83480       {
83481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83482       };
83483     } catch (std::exception& e) {
83484       {
83485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83486       };
83487     } catch (Dali::DaliException e) {
83488       {
83489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83490       };
83491     } catch (...) {
83492       {
83493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83494       };
83495     }
83496   }
83497
83498 }
83499
83500
83501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83503   unsigned int arg2 ;
83504
83505   arg1 = (Dali::Toolkit::TableView *)jarg1;
83506   arg2 = (unsigned int)jarg2;
83507   {
83508     try {
83509       (arg1)->DeleteRow(arg2);
83510     } catch (std::out_of_range& e) {
83511       {
83512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83513       };
83514     } catch (std::exception& e) {
83515       {
83516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83517       };
83518     } catch (Dali::DaliException e) {
83519       {
83520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83521       };
83522     } catch (...) {
83523       {
83524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83525       };
83526     }
83527   }
83528
83529 }
83530
83531
83532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83534   unsigned int arg2 ;
83535   std::vector< Dali::Actor > *arg3 = 0 ;
83536
83537   arg1 = (Dali::Toolkit::TableView *)jarg1;
83538   arg2 = (unsigned int)jarg2;
83539   arg3 = (std::vector< Dali::Actor > *)jarg3;
83540   if (!arg3) {
83541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83542     return ;
83543   }
83544   {
83545     try {
83546       (arg1)->DeleteRow(arg2,*arg3);
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83554       };
83555     } catch (Dali::DaliException e) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83558       };
83559     } catch (...) {
83560       {
83561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83562       };
83563     }
83564   }
83565
83566 }
83567
83568
83569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83570   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83571   unsigned int arg2 ;
83572
83573   arg1 = (Dali::Toolkit::TableView *)jarg1;
83574   arg2 = (unsigned int)jarg2;
83575   {
83576     try {
83577       (arg1)->InsertColumn(arg2);
83578     } catch (std::out_of_range& e) {
83579       {
83580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83581       };
83582     } catch (std::exception& e) {
83583       {
83584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83585       };
83586     } catch (Dali::DaliException e) {
83587       {
83588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83589       };
83590     } catch (...) {
83591       {
83592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83593       };
83594     }
83595   }
83596
83597 }
83598
83599
83600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83601   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83602   unsigned int arg2 ;
83603
83604   arg1 = (Dali::Toolkit::TableView *)jarg1;
83605   arg2 = (unsigned int)jarg2;
83606   {
83607     try {
83608       (arg1)->DeleteColumn(arg2);
83609     } catch (std::out_of_range& e) {
83610       {
83611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83612       };
83613     } catch (std::exception& e) {
83614       {
83615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83616       };
83617     } catch (Dali::DaliException e) {
83618       {
83619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83620       };
83621     } catch (...) {
83622       {
83623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83624       };
83625     }
83626   }
83627
83628 }
83629
83630
83631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83632   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83633   unsigned int arg2 ;
83634   std::vector< Dali::Actor > *arg3 = 0 ;
83635
83636   arg1 = (Dali::Toolkit::TableView *)jarg1;
83637   arg2 = (unsigned int)jarg2;
83638   arg3 = (std::vector< Dali::Actor > *)jarg3;
83639   if (!arg3) {
83640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83641     return ;
83642   }
83643   {
83644     try {
83645       (arg1)->DeleteColumn(arg2,*arg3);
83646     } catch (std::out_of_range& e) {
83647       {
83648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83649       };
83650     } catch (std::exception& e) {
83651       {
83652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83653       };
83654     } catch (Dali::DaliException e) {
83655       {
83656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83657       };
83658     } catch (...) {
83659       {
83660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83661       };
83662     }
83663   }
83664
83665 }
83666
83667
83668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83669   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83670   unsigned int arg2 ;
83671   unsigned int arg3 ;
83672
83673   arg1 = (Dali::Toolkit::TableView *)jarg1;
83674   arg2 = (unsigned int)jarg2;
83675   arg3 = (unsigned int)jarg3;
83676   {
83677     try {
83678       (arg1)->Resize(arg2,arg3);
83679     } catch (std::out_of_range& e) {
83680       {
83681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83682       };
83683     } catch (std::exception& e) {
83684       {
83685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83686       };
83687     } catch (Dali::DaliException e) {
83688       {
83689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83690       };
83691     } catch (...) {
83692       {
83693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83694       };
83695     }
83696   }
83697
83698 }
83699
83700
83701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83702   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83703   unsigned int arg2 ;
83704   unsigned int arg3 ;
83705   std::vector< Dali::Actor > *arg4 = 0 ;
83706
83707   arg1 = (Dali::Toolkit::TableView *)jarg1;
83708   arg2 = (unsigned int)jarg2;
83709   arg3 = (unsigned int)jarg3;
83710   arg4 = (std::vector< Dali::Actor > *)jarg4;
83711   if (!arg4) {
83712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83713     return ;
83714   }
83715   {
83716     try {
83717       (arg1)->Resize(arg2,arg3,*arg4);
83718     } catch (std::out_of_range& e) {
83719       {
83720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83721       };
83722     } catch (std::exception& e) {
83723       {
83724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83725       };
83726     } catch (Dali::DaliException e) {
83727       {
83728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83729       };
83730     } catch (...) {
83731       {
83732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83733       };
83734     }
83735   }
83736
83737 }
83738
83739
83740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83741   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83742   Dali::Size arg2 ;
83743   Dali::Size *argp2 ;
83744
83745   arg1 = (Dali::Toolkit::TableView *)jarg1;
83746   argp2 = (Dali::Size *)jarg2;
83747   if (!argp2) {
83748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83749     return ;
83750   }
83751   arg2 = *argp2;
83752   {
83753     try {
83754       (arg1)->SetCellPadding(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 void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83778   void * jresult ;
83779   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83780   Dali::Size result;
83781
83782   arg1 = (Dali::Toolkit::TableView *)jarg1;
83783   {
83784     try {
83785       result = (arg1)->GetCellPadding();
83786     } catch (std::out_of_range& e) {
83787       {
83788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83789       };
83790     } catch (std::exception& e) {
83791       {
83792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83793       };
83794     } catch (Dali::DaliException e) {
83795       {
83796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83797       };
83798     } catch (...) {
83799       {
83800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83801       };
83802     }
83803   }
83804
83805   jresult = new Dali::Size((const Dali::Size &)result);
83806   return jresult;
83807 }
83808
83809
83810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83811   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83812   unsigned int arg2 ;
83813
83814   arg1 = (Dali::Toolkit::TableView *)jarg1;
83815   arg2 = (unsigned int)jarg2;
83816   {
83817     try {
83818       (arg1)->SetFitHeight(arg2);
83819     } catch (std::out_of_range& e) {
83820       {
83821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83822       };
83823     } catch (std::exception& e) {
83824       {
83825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83826       };
83827     } catch (Dali::DaliException e) {
83828       {
83829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83830       };
83831     } catch (...) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83834       };
83835     }
83836   }
83837
83838 }
83839
83840
83841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83842   unsigned int jresult ;
83843   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83844   unsigned int arg2 ;
83845   bool result;
83846
83847   arg1 = (Dali::Toolkit::TableView *)jarg1;
83848   arg2 = (unsigned int)jarg2;
83849   {
83850     try {
83851       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83852     } catch (std::out_of_range& e) {
83853       {
83854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83855       };
83856     } catch (std::exception& e) {
83857       {
83858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83859       };
83860     } catch (Dali::DaliException e) {
83861       {
83862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83863       };
83864     } catch (...) {
83865       {
83866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83867       };
83868     }
83869   }
83870
83871   jresult = result;
83872   return jresult;
83873 }
83874
83875
83876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83877   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83878   unsigned int arg2 ;
83879
83880   arg1 = (Dali::Toolkit::TableView *)jarg1;
83881   arg2 = (unsigned int)jarg2;
83882   {
83883     try {
83884       (arg1)->SetFitWidth(arg2);
83885     } catch (std::out_of_range& e) {
83886       {
83887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83888       };
83889     } catch (std::exception& e) {
83890       {
83891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83892       };
83893     } catch (Dali::DaliException e) {
83894       {
83895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83896       };
83897     } catch (...) {
83898       {
83899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83900       };
83901     }
83902   }
83903
83904 }
83905
83906
83907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83908   unsigned int jresult ;
83909   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83910   unsigned int arg2 ;
83911   bool result;
83912
83913   arg1 = (Dali::Toolkit::TableView *)jarg1;
83914   arg2 = (unsigned int)jarg2;
83915   {
83916     try {
83917       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83918     } catch (std::out_of_range& e) {
83919       {
83920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83921       };
83922     } catch (std::exception& e) {
83923       {
83924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83925       };
83926     } catch (Dali::DaliException e) {
83927       {
83928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83929       };
83930     } catch (...) {
83931       {
83932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83933       };
83934     }
83935   }
83936
83937   jresult = result;
83938   return jresult;
83939 }
83940
83941
83942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83943   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83944   unsigned int arg2 ;
83945   float arg3 ;
83946
83947   arg1 = (Dali::Toolkit::TableView *)jarg1;
83948   arg2 = (unsigned int)jarg2;
83949   arg3 = (float)jarg3;
83950   {
83951     try {
83952       (arg1)->SetFixedHeight(arg2,arg3);
83953     } catch (std::out_of_range& e) {
83954       {
83955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83956       };
83957     } catch (std::exception& e) {
83958       {
83959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83960       };
83961     } catch (Dali::DaliException e) {
83962       {
83963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83964       };
83965     } catch (...) {
83966       {
83967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83968       };
83969     }
83970   }
83971
83972 }
83973
83974
83975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83976   float jresult ;
83977   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83978   unsigned int arg2 ;
83979   float result;
83980
83981   arg1 = (Dali::Toolkit::TableView *)jarg1;
83982   arg2 = (unsigned int)jarg2;
83983   {
83984     try {
83985       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83986     } catch (std::out_of_range& e) {
83987       {
83988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83989       };
83990     } catch (std::exception& e) {
83991       {
83992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83993       };
83994     } catch (Dali::DaliException e) {
83995       {
83996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83997       };
83998     } catch (...) {
83999       {
84000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84001       };
84002     }
84003   }
84004
84005   jresult = result;
84006   return jresult;
84007 }
84008
84009
84010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84011   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84012   unsigned int arg2 ;
84013   float arg3 ;
84014
84015   arg1 = (Dali::Toolkit::TableView *)jarg1;
84016   arg2 = (unsigned int)jarg2;
84017   arg3 = (float)jarg3;
84018   {
84019     try {
84020       (arg1)->SetRelativeHeight(arg2,arg3);
84021     } catch (std::out_of_range& e) {
84022       {
84023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84024       };
84025     } catch (std::exception& e) {
84026       {
84027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84028       };
84029     } catch (Dali::DaliException e) {
84030       {
84031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84032       };
84033     } catch (...) {
84034       {
84035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84036       };
84037     }
84038   }
84039
84040 }
84041
84042
84043 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84044   float jresult ;
84045   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84046   unsigned int arg2 ;
84047   float result;
84048
84049   arg1 = (Dali::Toolkit::TableView *)jarg1;
84050   arg2 = (unsigned int)jarg2;
84051   {
84052     try {
84053       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84054     } catch (std::out_of_range& e) {
84055       {
84056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84057       };
84058     } catch (std::exception& e) {
84059       {
84060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84061       };
84062     } catch (Dali::DaliException e) {
84063       {
84064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84065       };
84066     } catch (...) {
84067       {
84068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84069       };
84070     }
84071   }
84072
84073   jresult = result;
84074   return jresult;
84075 }
84076
84077
84078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84079   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84080   unsigned int arg2 ;
84081   float arg3 ;
84082
84083   arg1 = (Dali::Toolkit::TableView *)jarg1;
84084   arg2 = (unsigned int)jarg2;
84085   arg3 = (float)jarg3;
84086   {
84087     try {
84088       (arg1)->SetFixedWidth(arg2,arg3);
84089     } catch (std::out_of_range& e) {
84090       {
84091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84092       };
84093     } catch (std::exception& e) {
84094       {
84095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84096       };
84097     } catch (Dali::DaliException e) {
84098       {
84099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84100       };
84101     } catch (...) {
84102       {
84103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84104       };
84105     }
84106   }
84107
84108 }
84109
84110
84111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84112   float jresult ;
84113   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84114   unsigned int arg2 ;
84115   float result;
84116
84117   arg1 = (Dali::Toolkit::TableView *)jarg1;
84118   arg2 = (unsigned int)jarg2;
84119   {
84120     try {
84121       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84122     } catch (std::out_of_range& e) {
84123       {
84124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84125       };
84126     } catch (std::exception& e) {
84127       {
84128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84129       };
84130     } catch (Dali::DaliException e) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84133       };
84134     } catch (...) {
84135       {
84136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84137       };
84138     }
84139   }
84140
84141   jresult = result;
84142   return jresult;
84143 }
84144
84145
84146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84147   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84148   unsigned int arg2 ;
84149   float arg3 ;
84150
84151   arg1 = (Dali::Toolkit::TableView *)jarg1;
84152   arg2 = (unsigned int)jarg2;
84153   arg3 = (float)jarg3;
84154   {
84155     try {
84156       (arg1)->SetRelativeWidth(arg2,arg3);
84157     } catch (std::out_of_range& e) {
84158       {
84159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84160       };
84161     } catch (std::exception& e) {
84162       {
84163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84164       };
84165     } catch (Dali::DaliException e) {
84166       {
84167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84168       };
84169     } catch (...) {
84170       {
84171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84172       };
84173     }
84174   }
84175
84176 }
84177
84178
84179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84180   float jresult ;
84181   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84182   unsigned int arg2 ;
84183   float result;
84184
84185   arg1 = (Dali::Toolkit::TableView *)jarg1;
84186   arg2 = (unsigned int)jarg2;
84187   {
84188     try {
84189       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84190     } catch (std::out_of_range& e) {
84191       {
84192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84193       };
84194     } catch (std::exception& e) {
84195       {
84196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84197       };
84198     } catch (Dali::DaliException e) {
84199       {
84200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84201       };
84202     } catch (...) {
84203       {
84204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84205       };
84206     }
84207   }
84208
84209   jresult = result;
84210   return jresult;
84211 }
84212
84213
84214 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84215   unsigned int jresult ;
84216   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84217   unsigned int result;
84218
84219   arg1 = (Dali::Toolkit::TableView *)jarg1;
84220   {
84221     try {
84222       result = (unsigned int)(arg1)->GetRows();
84223     } catch (std::out_of_range& e) {
84224       {
84225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (std::exception& e) {
84228       {
84229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84230       };
84231     } catch (Dali::DaliException e) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84234       };
84235     } catch (...) {
84236       {
84237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84238       };
84239     }
84240   }
84241
84242   jresult = result;
84243   return jresult;
84244 }
84245
84246
84247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84248   unsigned int jresult ;
84249   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84250   unsigned int result;
84251
84252   arg1 = (Dali::Toolkit::TableView *)jarg1;
84253   {
84254     try {
84255       result = (unsigned int)(arg1)->GetColumns();
84256     } catch (std::out_of_range& e) {
84257       {
84258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84259       };
84260     } catch (std::exception& e) {
84261       {
84262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84263       };
84264     } catch (Dali::DaliException e) {
84265       {
84266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84267       };
84268     } catch (...) {
84269       {
84270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84271       };
84272     }
84273   }
84274
84275   jresult = result;
84276   return jresult;
84277 }
84278
84279
84280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84281   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84282   Dali::Toolkit::TableView::CellPosition arg2 ;
84283   Dali::HorizontalAlignment::Type arg3 ;
84284   Dali::VerticalAlignment::Type arg4 ;
84285   Dali::Toolkit::TableView::CellPosition *argp2 ;
84286
84287   arg1 = (Dali::Toolkit::TableView *)jarg1;
84288   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84289   if (!argp2) {
84290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84291     return ;
84292   }
84293   arg2 = *argp2;
84294   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84295   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84296   {
84297     try {
84298       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84299     } catch (std::out_of_range& e) {
84300       {
84301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84302       };
84303     } catch (std::exception& e) {
84304       {
84305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84306       };
84307     } catch (Dali::DaliException e) {
84308       {
84309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84310       };
84311     } catch (...) {
84312       {
84313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84314       };
84315     }
84316   }
84317
84318 }
84319
84320
84321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84322   unsigned int jresult ;
84323   unsigned int result;
84324
84325   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84326   jresult = result;
84327   return jresult;
84328 }
84329
84330
84331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84332   int jresult ;
84333   int result;
84334
84335   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84336   jresult = (int)result;
84337   return jresult;
84338 }
84339
84340
84341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84342   int jresult ;
84343   int result;
84344
84345   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84346   jresult = (int)result;
84347   return jresult;
84348 }
84349
84350
84351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84352   int jresult ;
84353   int result;
84354
84355   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84356   jresult = (int)result;
84357   return jresult;
84358 }
84359
84360
84361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84362   int jresult ;
84363   int result;
84364
84365   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84366   jresult = (int)result;
84367   return jresult;
84368 }
84369
84370
84371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84372   int jresult ;
84373   int result;
84374
84375   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84376   jresult = (int)result;
84377   return jresult;
84378 }
84379
84380
84381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84382   int jresult ;
84383   int result;
84384
84385   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84386   jresult = (int)result;
84387   return jresult;
84388 }
84389
84390
84391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84392   int jresult ;
84393   int result;
84394
84395   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84396   jresult = (int)result;
84397   return jresult;
84398 }
84399
84400
84401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84402   int jresult ;
84403   int result;
84404
84405   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84406   jresult = (int)result;
84407   return jresult;
84408 }
84409
84410
84411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84412   int jresult ;
84413   int result;
84414
84415   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84416   jresult = (int)result;
84417   return jresult;
84418 }
84419
84420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84421   int jresult ;
84422   int result;
84423
84424   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84425   jresult = (int)result;
84426   return jresult;
84427 }
84428
84429
84430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84431   int jresult ;
84432   int result;
84433
84434   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84435   jresult = (int)result;
84436   return jresult;
84437 }
84438
84439
84440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84441   int jresult ;
84442   int result;
84443
84444   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84445   jresult = (int)result;
84446   return jresult;
84447 }
84448
84449
84450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84451   int jresult ;
84452   int result;
84453
84454   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84455   jresult = (int)result;
84456   return jresult;
84457 }
84458
84459
84460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84461   int jresult ;
84462   int result;
84463
84464   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84465   jresult = (int)result;
84466   return jresult;
84467 }
84468
84469
84470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84471   int jresult ;
84472   int result;
84473
84474   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84475   jresult = (int)result;
84476   return jresult;
84477 }
84478
84479
84480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84481   int jresult ;
84482   int result;
84483
84484   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84485   jresult = (int)result;
84486   return jresult;
84487 }
84488
84489
84490 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84491   int jresult ;
84492   int result;
84493
84494   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84495   jresult = (int)result;
84496   return jresult;
84497 }
84498
84499
84500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84501   int jresult ;
84502   int result;
84503
84504   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84505   jresult = (int)result;
84506   return jresult;
84507 }
84508
84509
84510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84511   int jresult ;
84512   int result;
84513
84514   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84515   jresult = (int)result;
84516   return jresult;
84517 }
84518
84519
84520 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84521   int jresult ;
84522   int result;
84523
84524   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84525   jresult = (int)result;
84526   return jresult;
84527 }
84528
84529
84530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84531   int jresult ;
84532   int result;
84533
84534   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84535   jresult = (int)result;
84536   return jresult;
84537 }
84538
84539
84540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84541   int jresult ;
84542   int result;
84543
84544   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84545   jresult = (int)result;
84546   return jresult;
84547 }
84548
84549
84550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84551   int jresult ;
84552   int result;
84553
84554   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84555   jresult = (int)result;
84556   return jresult;
84557 }
84558
84559
84560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84561   int jresult ;
84562   int result;
84563
84564   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84565   jresult = (int)result;
84566   return jresult;
84567 }
84568
84569
84570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84571   void * jresult ;
84572   Dali::Toolkit::TextLabel::Property *result = 0 ;
84573
84574   {
84575     try {
84576       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84577     } catch (std::out_of_range& e) {
84578       {
84579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84580       };
84581     } catch (std::exception& e) {
84582       {
84583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84584       };
84585     } catch (Dali::DaliException e) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84588       };
84589     } catch (...) {
84590       {
84591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84592       };
84593     }
84594   }
84595
84596   jresult = (void *)result;
84597   return jresult;
84598 }
84599
84600
84601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84602   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84603
84604   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84605   {
84606     try {
84607       delete arg1;
84608     } catch (std::out_of_range& e) {
84609       {
84610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84611       };
84612     } catch (std::exception& e) {
84613       {
84614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84615       };
84616     } catch (Dali::DaliException e) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84619       };
84620     } catch (...) {
84621       {
84622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84623       };
84624     }
84625   }
84626
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84631   void * jresult ;
84632   Dali::Toolkit::TextLabel result;
84633
84634   {
84635     try {
84636       result = Dali::Toolkit::TextLabel::New();
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (Dali::DaliException e) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655
84656   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84657   return jresult;
84658 }
84659
84660
84661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84662   void * jresult ;
84663   std::string *arg1 = 0 ;
84664   Dali::Toolkit::TextLabel result;
84665
84666   if (!jarg1) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84668     return 0;
84669   }
84670   std::string arg1_str(jarg1);
84671   arg1 = &arg1_str;
84672   {
84673     try {
84674       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84690       };
84691     }
84692   }
84693
84694   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84695
84696   //argout typemap for const std::string&
84697
84698   return jresult;
84699 }
84700
84701
84702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84703   void * jresult ;
84704   Dali::Toolkit::TextLabel *result = 0 ;
84705
84706   {
84707     try {
84708       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84709     } catch (std::out_of_range& e) {
84710       {
84711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84712       };
84713     } catch (std::exception& e) {
84714       {
84715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84716       };
84717     } catch (Dali::DaliException e) {
84718       {
84719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84720       };
84721     } catch (...) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84724       };
84725     }
84726   }
84727
84728   jresult = (void *)result;
84729   return jresult;
84730 }
84731
84732
84733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84734   void * jresult ;
84735   Dali::Toolkit::TextLabel *arg1 = 0 ;
84736   Dali::Toolkit::TextLabel *result = 0 ;
84737
84738   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84739   if (!arg1) {
84740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84741     return 0;
84742   }
84743   {
84744     try {
84745       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84746     } catch (std::out_of_range& e) {
84747       {
84748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84749       };
84750     } catch (std::exception& e) {
84751       {
84752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84753       };
84754     } catch (Dali::DaliException e) {
84755       {
84756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84757       };
84758     } catch (...) {
84759       {
84760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84761       };
84762     }
84763   }
84764
84765   jresult = (void *)result;
84766   return jresult;
84767 }
84768
84769
84770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84771   void * jresult ;
84772   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84773   Dali::Toolkit::TextLabel *arg2 = 0 ;
84774   Dali::Toolkit::TextLabel *result = 0 ;
84775
84776   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84777   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84778   if (!arg2) {
84779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84780     return 0;
84781   }
84782   {
84783     try {
84784       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84785     } catch (std::out_of_range& e) {
84786       {
84787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84788       };
84789     } catch (std::exception& e) {
84790       {
84791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84792       };
84793     } catch (Dali::DaliException e) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84800       };
84801     }
84802   }
84803
84804   jresult = (void *)result;
84805   return jresult;
84806 }
84807
84808
84809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84810   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84811
84812   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84813   {
84814     try {
84815       delete arg1;
84816     } catch (std::out_of_range& e) {
84817       {
84818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84819       };
84820     } catch (std::exception& e) {
84821       {
84822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84823       };
84824     } catch (Dali::DaliException e) {
84825       {
84826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84827       };
84828     } catch (...) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84831       };
84832     }
84833   }
84834
84835 }
84836
84837
84838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84839   void * jresult ;
84840   Dali::BaseHandle arg1 ;
84841   Dali::BaseHandle *argp1 ;
84842   Dali::Toolkit::TextLabel result;
84843
84844   argp1 = (Dali::BaseHandle *)jarg1;
84845   if (!argp1) {
84846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84847     return 0;
84848   }
84849   arg1 = *argp1;
84850   {
84851     try {
84852       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84853     } catch (std::out_of_range& e) {
84854       {
84855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84856       };
84857     } catch (std::exception& e) {
84858       {
84859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84860       };
84861     } catch (Dali::DaliException e) {
84862       {
84863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84864       };
84865     } catch (...) {
84866       {
84867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84868       };
84869     }
84870   }
84871
84872   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84873   return jresult;
84874 }
84875
84876
84877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84878   void * jresult ;
84879   Dali::Toolkit::AccessibilityManager *result = 0 ;
84880
84881   {
84882     try {
84883       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84884     } catch (std::out_of_range& e) {
84885       {
84886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (std::exception& e) {
84889       {
84890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84891       };
84892     } catch (Dali::DaliException e) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84895       };
84896     } catch (...) {
84897       {
84898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84899       };
84900     }
84901   }
84902
84903   jresult = (void *)result;
84904   return jresult;
84905 }
84906
84907
84908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84909   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84910
84911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84912   {
84913     try {
84914       delete arg1;
84915     } catch (std::out_of_range& e) {
84916       {
84917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84918       };
84919     } catch (std::exception& e) {
84920       {
84921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84922       };
84923     } catch (Dali::DaliException e) {
84924       {
84925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84926       };
84927     } catch (...) {
84928       {
84929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84930       };
84931     }
84932   }
84933
84934 }
84935
84936
84937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84938   void * jresult ;
84939   Dali::Toolkit::AccessibilityManager result;
84940
84941   {
84942     try {
84943       result = Dali::Toolkit::AccessibilityManager::Get();
84944     } catch (std::out_of_range& e) {
84945       {
84946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84947       };
84948     } catch (std::exception& e) {
84949       {
84950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84951       };
84952     } catch (Dali::DaliException e) {
84953       {
84954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84955       };
84956     } catch (...) {
84957       {
84958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84959       };
84960     }
84961   }
84962
84963   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84964   return jresult;
84965 }
84966
84967
84968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84970   Dali::Actor arg2 ;
84971   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84972   std::string *arg4 = 0 ;
84973   Dali::Actor *argp2 ;
84974
84975   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84976   argp2 = (Dali::Actor *)jarg2;
84977   if (!argp2) {
84978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84979     return ;
84980   }
84981   arg2 = *argp2;
84982   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84983   if (!jarg4) {
84984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84985     return ;
84986   }
84987   std::string arg4_str(jarg4);
84988   arg4 = &arg4_str;
84989   {
84990     try {
84991       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84992     } catch (std::out_of_range& e) {
84993       {
84994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84995       };
84996     } catch (std::exception& e) {
84997       {
84998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84999       };
85000     } catch (Dali::DaliException e) {
85001       {
85002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85003       };
85004     } catch (...) {
85005       {
85006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85007       };
85008     }
85009   }
85010
85011
85012   //argout typemap for const std::string&
85013
85014 }
85015
85016
85017 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85018   char * jresult ;
85019   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85020   Dali::Actor arg2 ;
85021   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85022   Dali::Actor *argp2 ;
85023   std::string result;
85024
85025   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85026   argp2 = (Dali::Actor *)jarg2;
85027   if (!argp2) {
85028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85029     return 0;
85030   }
85031   arg2 = *argp2;
85032   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85033   {
85034     try {
85035       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85036     } catch (std::out_of_range& e) {
85037       {
85038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85039       };
85040     } catch (std::exception& e) {
85041       {
85042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85043       };
85044     } catch (Dali::DaliException e) {
85045       {
85046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85047       };
85048     } catch (...) {
85049       {
85050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85051       };
85052     }
85053   }
85054
85055   jresult = SWIG_csharp_string_callback((&result)->c_str());
85056   return jresult;
85057 }
85058
85059
85060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85061   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85062   Dali::Actor arg2 ;
85063   unsigned int arg3 ;
85064   Dali::Actor *argp2 ;
85065
85066   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85067   argp2 = (Dali::Actor *)jarg2;
85068   if (!argp2) {
85069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85070     return ;
85071   }
85072   arg2 = *argp2;
85073   arg3 = (unsigned int)jarg3;
85074   {
85075     try {
85076       (arg1)->SetFocusOrder(arg2,arg3);
85077     } catch (std::out_of_range& e) {
85078       {
85079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85080       };
85081     } catch (std::exception& e) {
85082       {
85083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85084       };
85085     } catch (Dali::DaliException e) {
85086       {
85087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85088       };
85089     } catch (...) {
85090       {
85091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85092       };
85093     }
85094   }
85095
85096 }
85097
85098
85099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85100   unsigned int jresult ;
85101   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85102   Dali::Actor arg2 ;
85103   Dali::Actor *argp2 ;
85104   unsigned int result;
85105
85106   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85107   argp2 = (Dali::Actor *)jarg2;
85108   if (!argp2) {
85109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85110     return 0;
85111   }
85112   arg2 = *argp2;
85113   {
85114     try {
85115       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85116     } catch (std::out_of_range& e) {
85117       {
85118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85119       };
85120     } catch (std::exception& e) {
85121       {
85122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85123       };
85124     } catch (Dali::DaliException e) {
85125       {
85126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85127       };
85128     } catch (...) {
85129       {
85130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85131       };
85132     }
85133   }
85134
85135   jresult = result;
85136   return jresult;
85137 }
85138
85139
85140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85141   unsigned int jresult ;
85142   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85143   unsigned int result;
85144
85145   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85146   {
85147     try {
85148       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85149     } catch (std::out_of_range& e) {
85150       {
85151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85152       };
85153     } catch (std::exception& e) {
85154       {
85155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85156       };
85157     } catch (Dali::DaliException e) {
85158       {
85159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85160       };
85161     } catch (...) {
85162       {
85163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85164       };
85165     }
85166   }
85167
85168   jresult = result;
85169   return jresult;
85170 }
85171
85172
85173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85174   void * jresult ;
85175   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85176   unsigned int arg2 ;
85177   Dali::Actor result;
85178
85179   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85180   arg2 = (unsigned int)jarg2;
85181   {
85182     try {
85183       result = (arg1)->GetActorByFocusOrder(arg2);
85184     } catch (std::out_of_range& e) {
85185       {
85186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85187       };
85188     } catch (std::exception& e) {
85189       {
85190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85191       };
85192     } catch (Dali::DaliException e) {
85193       {
85194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85195       };
85196     } catch (...) {
85197       {
85198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85199       };
85200     }
85201   }
85202
85203   jresult = new Dali::Actor((const Dali::Actor &)result);
85204   return jresult;
85205 }
85206
85207
85208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85209   unsigned int jresult ;
85210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85211   Dali::Actor arg2 ;
85212   Dali::Actor *argp2 ;
85213   bool result;
85214
85215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85216   argp2 = (Dali::Actor *)jarg2;
85217   if (!argp2) {
85218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85219     return 0;
85220   }
85221   arg2 = *argp2;
85222   {
85223     try {
85224       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85225     } catch (std::out_of_range& e) {
85226       {
85227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85228       };
85229     } catch (std::exception& e) {
85230       {
85231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85232       };
85233     } catch (Dali::DaliException e) {
85234       {
85235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85236       };
85237     } catch (...) {
85238       {
85239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85240       };
85241     }
85242   }
85243
85244   jresult = result;
85245   return jresult;
85246 }
85247
85248
85249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85250   void * jresult ;
85251   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85252   Dali::Actor result;
85253
85254   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85255   {
85256     try {
85257       result = (arg1)->GetCurrentFocusActor();
85258     } catch (std::out_of_range& e) {
85259       {
85260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85261       };
85262     } catch (std::exception& e) {
85263       {
85264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85265       };
85266     } catch (Dali::DaliException e) {
85267       {
85268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85269       };
85270     } catch (...) {
85271       {
85272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85273       };
85274     }
85275   }
85276
85277   jresult = new Dali::Actor((const Dali::Actor &)result);
85278   return jresult;
85279 }
85280
85281
85282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85283   void * jresult ;
85284   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85285   Dali::Actor result;
85286
85287   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85288   {
85289     try {
85290       result = (arg1)->GetCurrentFocusGroup();
85291     } catch (std::out_of_range& e) {
85292       {
85293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85294       };
85295     } catch (std::exception& e) {
85296       {
85297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85298       };
85299     } catch (Dali::DaliException e) {
85300       {
85301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85302       };
85303     } catch (...) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85306       };
85307     }
85308   }
85309
85310   jresult = new Dali::Actor((const Dali::Actor &)result);
85311   return jresult;
85312 }
85313
85314
85315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85316   unsigned int jresult ;
85317   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85318   unsigned int result;
85319
85320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85321   {
85322     try {
85323       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85324     } catch (std::out_of_range& e) {
85325       {
85326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85327       };
85328     } catch (std::exception& e) {
85329       {
85330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85331       };
85332     } catch (Dali::DaliException e) {
85333       {
85334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85335       };
85336     } catch (...) {
85337       {
85338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85339       };
85340     }
85341   }
85342
85343   jresult = result;
85344   return jresult;
85345 }
85346
85347
85348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85349   unsigned int jresult ;
85350   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85351   bool result;
85352
85353   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85354   {
85355     try {
85356       result = (bool)(arg1)->MoveFocusForward();
85357     } catch (std::out_of_range& e) {
85358       {
85359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85360       };
85361     } catch (std::exception& e) {
85362       {
85363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85364       };
85365     } catch (Dali::DaliException e) {
85366       {
85367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85368       };
85369     } catch (...) {
85370       {
85371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85372       };
85373     }
85374   }
85375
85376   jresult = result;
85377   return jresult;
85378 }
85379
85380
85381 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85382   unsigned int jresult ;
85383   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85384   bool result;
85385
85386   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85387   {
85388     try {
85389       result = (bool)(arg1)->MoveFocusBackward();
85390     } catch (std::out_of_range& e) {
85391       {
85392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85393       };
85394     } catch (std::exception& e) {
85395       {
85396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85397       };
85398     } catch (Dali::DaliException e) {
85399       {
85400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85401       };
85402     } catch (...) {
85403       {
85404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85405       };
85406     }
85407   }
85408
85409   jresult = result;
85410   return jresult;
85411 }
85412
85413
85414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85415   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85416
85417   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85418   {
85419     try {
85420       (arg1)->ClearFocus();
85421     } catch (std::out_of_range& e) {
85422       {
85423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85424       };
85425     } catch (std::exception& e) {
85426       {
85427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85428       };
85429     } catch (Dali::DaliException e) {
85430       {
85431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85432       };
85433     } catch (...) {
85434       {
85435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85436       };
85437     }
85438   }
85439
85440 }
85441
85442
85443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85444   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85445
85446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85447   {
85448     try {
85449       (arg1)->Reset();
85450     } catch (std::out_of_range& e) {
85451       {
85452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85453       };
85454     } catch (std::exception& e) {
85455       {
85456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85457       };
85458     } catch (Dali::DaliException e) {
85459       {
85460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85461       };
85462     } catch (...) {
85463       {
85464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85465       };
85466     }
85467   }
85468
85469 }
85470
85471
85472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85473   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85474   Dali::Actor arg2 ;
85475   bool arg3 ;
85476   Dali::Actor *argp2 ;
85477
85478   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85479   argp2 = (Dali::Actor *)jarg2;
85480   if (!argp2) {
85481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85482     return ;
85483   }
85484   arg2 = *argp2;
85485   arg3 = jarg3 ? true : false;
85486   {
85487     try {
85488       (arg1)->SetFocusGroup(arg2,arg3);
85489     } catch (std::out_of_range& e) {
85490       {
85491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85492       };
85493     } catch (std::exception& e) {
85494       {
85495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85496       };
85497     } catch (Dali::DaliException e) {
85498       {
85499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85500       };
85501     } catch (...) {
85502       {
85503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85504       };
85505     }
85506   }
85507
85508 }
85509
85510
85511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85512   unsigned int jresult ;
85513   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85514   Dali::Actor arg2 ;
85515   Dali::Actor *argp2 ;
85516   bool result;
85517
85518   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85519   argp2 = (Dali::Actor *)jarg2;
85520   if (!argp2) {
85521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85522     return 0;
85523   }
85524   arg2 = *argp2;
85525   {
85526     try {
85527       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
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_SetGroupMode(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)->SetGroupMode(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_GetGroupMode(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)->GetGroupMode();
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_SetWrapMode(void * jarg1, unsigned int jarg2) {
85617   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85618   bool arg2 ;
85619
85620   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85621   arg2 = jarg2 ? true : false;
85622   {
85623     try {
85624       (arg1)->SetWrapMode(arg2);
85625     } catch (std::out_of_range& e) {
85626       {
85627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85628       };
85629     } catch (std::exception& e) {
85630       {
85631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85632       };
85633     } catch (Dali::DaliException e) {
85634       {
85635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85636       };
85637     } catch (...) {
85638       {
85639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85640       };
85641     }
85642   }
85643
85644 }
85645
85646
85647 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85648   unsigned int jresult ;
85649   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85650   bool result;
85651
85652   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85653   {
85654     try {
85655       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85656     } catch (std::out_of_range& e) {
85657       {
85658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85659       };
85660     } catch (std::exception& e) {
85661       {
85662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85663       };
85664     } catch (Dali::DaliException e) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85667       };
85668     } catch (...) {
85669       {
85670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85671       };
85672     }
85673   }
85674
85675   jresult = result;
85676   return jresult;
85677 }
85678
85679
85680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85681   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85682   Dali::Actor arg2 ;
85683   Dali::Actor *argp2 ;
85684
85685   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85686   argp2 = (Dali::Actor *)jarg2;
85687   if (!argp2) {
85688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85689     return ;
85690   }
85691   arg2 = *argp2;
85692   {
85693     try {
85694       (arg1)->SetFocusIndicatorActor(arg2);
85695     } catch (std::out_of_range& e) {
85696       {
85697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85698       };
85699     } catch (std::exception& e) {
85700       {
85701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85702       };
85703     } catch (Dali::DaliException e) {
85704       {
85705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85706       };
85707     } catch (...) {
85708       {
85709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85710       };
85711     }
85712   }
85713
85714 }
85715
85716
85717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85718   void * jresult ;
85719   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85720   Dali::Actor result;
85721
85722   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85723   {
85724     try {
85725       result = (arg1)->GetFocusIndicatorActor();
85726     } catch (std::out_of_range& e) {
85727       {
85728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85729       };
85730     } catch (std::exception& e) {
85731       {
85732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85733       };
85734     } catch (Dali::DaliException e) {
85735       {
85736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85737       };
85738     } catch (...) {
85739       {
85740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85741       };
85742     }
85743   }
85744
85745   jresult = new Dali::Actor((const Dali::Actor &)result);
85746   return jresult;
85747 }
85748
85749
85750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85751   void * jresult ;
85752   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85753   Dali::Actor arg2 ;
85754   Dali::Actor *argp2 ;
85755   Dali::Actor result;
85756
85757   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85758   argp2 = (Dali::Actor *)jarg2;
85759   if (!argp2) {
85760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85761     return 0;
85762   }
85763   arg2 = *argp2;
85764   {
85765     try {
85766       result = (arg1)->GetFocusGroup(arg2);
85767     } catch (std::out_of_range& e) {
85768       {
85769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85770       };
85771     } catch (std::exception& e) {
85772       {
85773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85774       };
85775     } catch (Dali::DaliException e) {
85776       {
85777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85778       };
85779     } catch (...) {
85780       {
85781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85782       };
85783     }
85784   }
85785
85786   jresult = new Dali::Actor((const Dali::Actor &)result);
85787   return jresult;
85788 }
85789
85790
85791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85792   void * jresult ;
85793   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85794   Dali::Vector2 result;
85795
85796   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85797   {
85798     try {
85799       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85800     } catch (std::out_of_range& e) {
85801       {
85802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85803       };
85804     } catch (std::exception& e) {
85805       {
85806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85807       };
85808     } catch (Dali::DaliException e) {
85809       {
85810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85811       };
85812     } catch (...) {
85813       {
85814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85815       };
85816     }
85817   }
85818
85819   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85820   return jresult;
85821 }
85822
85823
85824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85825   void * jresult ;
85826   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85827   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85828
85829   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85830   {
85831     try {
85832       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85833     } catch (std::out_of_range& e) {
85834       {
85835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85836       };
85837     } catch (std::exception& e) {
85838       {
85839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85840       };
85841     } catch (Dali::DaliException e) {
85842       {
85843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85844       };
85845     } catch (...) {
85846       {
85847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85848       };
85849     }
85850   }
85851
85852   jresult = (void *)result;
85853   return jresult;
85854 }
85855
85856
85857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85858   void * jresult ;
85859   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85860   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85861
85862   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85863   {
85864     try {
85865       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85866     } catch (std::out_of_range& e) {
85867       {
85868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85869       };
85870     } catch (std::exception& e) {
85871       {
85872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85873       };
85874     } catch (Dali::DaliException e) {
85875       {
85876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85877       };
85878     } catch (...) {
85879       {
85880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85881       };
85882     }
85883   }
85884
85885   jresult = (void *)result;
85886   return jresult;
85887 }
85888
85889
85890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85891   void * jresult ;
85892   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85893   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85894
85895   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85896   {
85897     try {
85898       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85899     } catch (std::out_of_range& e) {
85900       {
85901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85902       };
85903     } catch (std::exception& e) {
85904       {
85905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85906       };
85907     } catch (Dali::DaliException e) {
85908       {
85909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85910       };
85911     } catch (...) {
85912       {
85913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85914       };
85915     }
85916   }
85917
85918   jresult = (void *)result;
85919   return jresult;
85920 }
85921
85922
85923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85924   void * jresult ;
85925   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85926   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85927
85928   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85929   {
85930     try {
85931       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85932     } catch (std::out_of_range& e) {
85933       {
85934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85935       };
85936     } catch (std::exception& e) {
85937       {
85938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85939       };
85940     } catch (Dali::DaliException e) {
85941       {
85942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85943       };
85944     } catch (...) {
85945       {
85946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85947       };
85948     }
85949   }
85950
85951   jresult = (void *)result;
85952   return jresult;
85953 }
85954
85955
85956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85957   void * jresult ;
85958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85959   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85960
85961   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85962   {
85963     try {
85964       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85965     } catch (std::out_of_range& e) {
85966       {
85967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85968       };
85969     } catch (std::exception& e) {
85970       {
85971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85972       };
85973     } catch (Dali::DaliException e) {
85974       {
85975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85976       };
85977     } catch (...) {
85978       {
85979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85980       };
85981     }
85982   }
85983
85984   jresult = (void *)result;
85985   return jresult;
85986 }
85987
85988
85989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85990   void * jresult ;
85991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85992   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85993
85994   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85995   {
85996     try {
85997       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85998     } catch (std::out_of_range& e) {
85999       {
86000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86001       };
86002     } catch (std::exception& e) {
86003       {
86004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86005       };
86006     } catch (Dali::DaliException e) {
86007       {
86008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86009       };
86010     } catch (...) {
86011       {
86012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86013       };
86014     }
86015   }
86016
86017   jresult = (void *)result;
86018   return jresult;
86019 }
86020
86021
86022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86023   void * jresult ;
86024   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86025   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86026
86027   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86028   {
86029     try {
86030       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86031     } catch (std::out_of_range& e) {
86032       {
86033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86034       };
86035     } catch (std::exception& e) {
86036       {
86037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86038       };
86039     } catch (Dali::DaliException e) {
86040       {
86041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86042       };
86043     } catch (...) {
86044       {
86045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86046       };
86047     }
86048   }
86049
86050   jresult = (void *)result;
86051   return jresult;
86052 }
86053
86054
86055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86056   void * jresult ;
86057   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86058   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86059
86060   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86061   {
86062     try {
86063       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86064     } catch (std::out_of_range& e) {
86065       {
86066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86067       };
86068     } catch (std::exception& e) {
86069       {
86070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86071       };
86072     } catch (Dali::DaliException e) {
86073       {
86074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86075       };
86076     } catch (...) {
86077       {
86078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86079       };
86080     }
86081   }
86082
86083   jresult = (void *)result;
86084   return jresult;
86085 }
86086
86087
86088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86089   void * jresult ;
86090   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86091   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86092
86093   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86094   {
86095     try {
86096       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86097     } catch (std::out_of_range& e) {
86098       {
86099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86100       };
86101     } catch (std::exception& e) {
86102       {
86103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (Dali::DaliException e) {
86106       {
86107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86108       };
86109     } catch (...) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86112       };
86113     }
86114   }
86115
86116   jresult = (void *)result;
86117   return jresult;
86118 }
86119
86120
86121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86122   void * jresult ;
86123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86124   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86125
86126   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86127   {
86128     try {
86129       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86130     } catch (std::out_of_range& e) {
86131       {
86132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86133       };
86134     } catch (std::exception& e) {
86135       {
86136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (Dali::DaliException e) {
86139       {
86140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86141       };
86142     } catch (...) {
86143       {
86144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86145       };
86146     }
86147   }
86148
86149   jresult = (void *)result;
86150   return jresult;
86151 }
86152
86153
86154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86155   void * jresult ;
86156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86157   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86158
86159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86160   {
86161     try {
86162       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86163     } catch (std::out_of_range& e) {
86164       {
86165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86166       };
86167     } catch (std::exception& e) {
86168       {
86169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86170       };
86171     } catch (Dali::DaliException e) {
86172       {
86173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86174       };
86175     } catch (...) {
86176       {
86177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86178       };
86179     }
86180   }
86181
86182   jresult = (void *)result;
86183   return jresult;
86184 }
86185
86186
86187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86188   void * jresult ;
86189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86190   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86191
86192   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86193   {
86194     try {
86195       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86196     } catch (std::out_of_range& e) {
86197       {
86198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86199       };
86200     } catch (std::exception& e) {
86201       {
86202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86203       };
86204     } catch (Dali::DaliException e) {
86205       {
86206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86207       };
86208     } catch (...) {
86209       {
86210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86211       };
86212     }
86213   }
86214
86215   jresult = (void *)result;
86216   return jresult;
86217 }
86218
86219
86220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86221   void * jresult ;
86222   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86223   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86224
86225   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86226   {
86227     try {
86228       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86229     } catch (std::out_of_range& e) {
86230       {
86231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86232       };
86233     } catch (std::exception& e) {
86234       {
86235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (Dali::DaliException e) {
86238       {
86239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86240       };
86241     } catch (...) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86244       };
86245     }
86246   }
86247
86248   jresult = (void *)result;
86249   return jresult;
86250 }
86251
86252
86253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86254   void * jresult ;
86255   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86256   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86257
86258   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86259   {
86260     try {
86261       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86262     } catch (std::out_of_range& e) {
86263       {
86264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86265       };
86266     } catch (std::exception& e) {
86267       {
86268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86269       };
86270     } catch (Dali::DaliException e) {
86271       {
86272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86273       };
86274     } catch (...) {
86275       {
86276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86277       };
86278     }
86279   }
86280
86281   jresult = (void *)result;
86282   return jresult;
86283 }
86284
86285
86286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86287   void * jresult ;
86288   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86289   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86290
86291   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86292   {
86293     try {
86294       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86295     } catch (std::out_of_range& e) {
86296       {
86297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86298       };
86299     } catch (std::exception& e) {
86300       {
86301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86302       };
86303     } catch (Dali::DaliException e) {
86304       {
86305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86306       };
86307     } catch (...) {
86308       {
86309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86310       };
86311     }
86312   }
86313
86314   jresult = (void *)result;
86315   return jresult;
86316 }
86317
86318
86319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86320   void * jresult ;
86321   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86322   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86323
86324   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86325   {
86326     try {
86327       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86328     } catch (std::out_of_range& e) {
86329       {
86330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86331       };
86332     } catch (std::exception& e) {
86333       {
86334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86335       };
86336     } catch (Dali::DaliException e) {
86337       {
86338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86339       };
86340     } catch (...) {
86341       {
86342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86343       };
86344     }
86345   }
86346
86347   jresult = (void *)result;
86348   return jresult;
86349 }
86350
86351
86352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86353   void * jresult ;
86354   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86355   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86356
86357   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86358   {
86359     try {
86360       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86361     } catch (std::out_of_range& e) {
86362       {
86363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86364       };
86365     } catch (std::exception& e) {
86366       {
86367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86368       };
86369     } catch (Dali::DaliException e) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86372       };
86373     } catch (...) {
86374       {
86375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86376       };
86377     }
86378   }
86379
86380   jresult = (void *)result;
86381   return jresult;
86382 }
86383
86384
86385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86386   void * jresult ;
86387   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86388   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86389
86390   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86391   {
86392     try {
86393       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86394     } catch (std::out_of_range& e) {
86395       {
86396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86397       };
86398     } catch (std::exception& e) {
86399       {
86400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86401       };
86402     } catch (Dali::DaliException e) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86405       };
86406     } catch (...) {
86407       {
86408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86409       };
86410     }
86411   }
86412
86413   jresult = (void *)result;
86414   return jresult;
86415 }
86416
86417
86418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86419   void * jresult ;
86420   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86421   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86422
86423   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86424   {
86425     try {
86426       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86427     } catch (std::out_of_range& e) {
86428       {
86429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (std::exception& e) {
86432       {
86433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86434       };
86435     } catch (Dali::DaliException e) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86438       };
86439     } catch (...) {
86440       {
86441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86442       };
86443     }
86444   }
86445
86446   jresult = (void *)result;
86447   return jresult;
86448 }
86449
86450
86451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86452   void * jresult ;
86453   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86454   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86455
86456   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86457   {
86458     try {
86459       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86460     } catch (std::out_of_range& e) {
86461       {
86462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86463       };
86464     } catch (std::exception& e) {
86465       {
86466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86467       };
86468     } catch (Dali::DaliException e) {
86469       {
86470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86471       };
86472     } catch (...) {
86473       {
86474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86475       };
86476     }
86477   }
86478
86479   jresult = (void *)result;
86480   return jresult;
86481 }
86482
86483
86484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86485   void * jresult ;
86486   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86487   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86488
86489   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86490   {
86491     try {
86492       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86493     } catch (std::out_of_range& e) {
86494       {
86495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86496       };
86497     } catch (std::exception& e) {
86498       {
86499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86500       };
86501     } catch (Dali::DaliException e) {
86502       {
86503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86504       };
86505     } catch (...) {
86506       {
86507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86508       };
86509     }
86510   }
86511
86512   jresult = (void *)result;
86513   return jresult;
86514 }
86515
86516
86517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86518   void * jresult ;
86519   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86520   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86521
86522   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86523   {
86524     try {
86525       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86526     } catch (std::out_of_range& e) {
86527       {
86528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86529       };
86530     } catch (std::exception& e) {
86531       {
86532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86533       };
86534     } catch (Dali::DaliException e) {
86535       {
86536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86537       };
86538     } catch (...) {
86539       {
86540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86541       };
86542     }
86543   }
86544
86545   jresult = (void *)result;
86546   return jresult;
86547 }
86548
86549
86550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86551   void * jresult ;
86552   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86553   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86554
86555   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86556   {
86557     try {
86558       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86559     } catch (std::out_of_range& e) {
86560       {
86561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86562       };
86563     } catch (std::exception& e) {
86564       {
86565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86566       };
86567     } catch (Dali::DaliException e) {
86568       {
86569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86570       };
86571     } catch (...) {
86572       {
86573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86574       };
86575     }
86576   }
86577
86578   jresult = (void *)result;
86579   return jresult;
86580 }
86581
86582
86583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86584   void * jresult ;
86585   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86586   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86587
86588   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86589   {
86590     try {
86591       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86592     } catch (std::out_of_range& e) {
86593       {
86594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86595       };
86596     } catch (std::exception& e) {
86597       {
86598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86599       };
86600     } catch (Dali::DaliException e) {
86601       {
86602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86603       };
86604     } catch (...) {
86605       {
86606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86607       };
86608     }
86609   }
86610
86611   jresult = (void *)result;
86612   return jresult;
86613 }
86614
86615
86616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86617   void * jresult ;
86618   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86619   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86620
86621   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86622   {
86623     try {
86624       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86625     } catch (std::out_of_range& e) {
86626       {
86627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86628       };
86629     } catch (std::exception& e) {
86630       {
86631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86632       };
86633     } catch (Dali::DaliException e) {
86634       {
86635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86636       };
86637     } catch (...) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86640       };
86641     }
86642   }
86643
86644   jresult = (void *)result;
86645   return jresult;
86646 }
86647
86648
86649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86650   void * jresult ;
86651   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86652   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86653
86654   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86655   {
86656     try {
86657       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86658     } catch (std::out_of_range& e) {
86659       {
86660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86661       };
86662     } catch (std::exception& e) {
86663       {
86664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (Dali::DaliException e) {
86667       {
86668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86669       };
86670     } catch (...) {
86671       {
86672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86673       };
86674     }
86675   }
86676
86677   jresult = (void *)result;
86678   return jresult;
86679 }
86680
86681
86682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86683   void * jresult ;
86684   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86685   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86686
86687   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86688   {
86689     try {
86690       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86691     } catch (std::out_of_range& e) {
86692       {
86693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86694       };
86695     } catch (std::exception& e) {
86696       {
86697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86698       };
86699     } catch (Dali::DaliException e) {
86700       {
86701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86702       };
86703     } catch (...) {
86704       {
86705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86706       };
86707     }
86708   }
86709
86710   jresult = (void *)result;
86711   return jresult;
86712 }
86713
86714
86715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86716   void * jresult ;
86717   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86718   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86719
86720   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86721   {
86722     try {
86723       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86724     } catch (std::out_of_range& e) {
86725       {
86726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (std::exception& e) {
86729       {
86730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86731       };
86732     } catch (Dali::DaliException e) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86735       };
86736     } catch (...) {
86737       {
86738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86739       };
86740     }
86741   }
86742
86743   jresult = (void *)result;
86744   return jresult;
86745 }
86746
86747
86748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86749   void * jresult ;
86750   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86751   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86752
86753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86754   {
86755     try {
86756       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
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_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86782   void * jresult ;
86783   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86784   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86785
86786   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86787   {
86788     try {
86789       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86790     } catch (std::out_of_range& e) {
86791       {
86792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86793       };
86794     } catch (std::exception& e) {
86795       {
86796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86797       };
86798     } catch (Dali::DaliException e) {
86799       {
86800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86801       };
86802     } catch (...) {
86803       {
86804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86805       };
86806     }
86807   }
86808
86809   jresult = (void *)result;
86810   return jresult;
86811 }
86812
86813
86814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86815   void * jresult ;
86816   Dali::Toolkit::StyleManager *result = 0 ;
86817
86818   {
86819     try {
86820       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86821     } catch (std::out_of_range& e) {
86822       {
86823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86824       };
86825     } catch (std::exception& e) {
86826       {
86827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86828       };
86829     } catch (Dali::DaliException e) {
86830       {
86831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86832       };
86833     } catch (...) {
86834       {
86835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86836       };
86837     }
86838   }
86839
86840   jresult = (void *)result;
86841   return jresult;
86842 }
86843
86844
86845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86846   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86847
86848   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86849   {
86850     try {
86851       delete arg1;
86852     } catch (std::out_of_range& e) {
86853       {
86854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86855       };
86856     } catch (std::exception& e) {
86857       {
86858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86859       };
86860     } catch (Dali::DaliException e) {
86861       {
86862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86863       };
86864     } catch (...) {
86865       {
86866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86867       };
86868     }
86869   }
86870
86871 }
86872
86873
86874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86875   void * jresult ;
86876   Dali::Toolkit::StyleManager result;
86877
86878   {
86879     try {
86880       result = Dali::Toolkit::StyleManager::Get();
86881     } catch (std::out_of_range& e) {
86882       {
86883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86884       };
86885     } catch (std::exception& e) {
86886       {
86887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86888       };
86889     } catch (Dali::DaliException e) {
86890       {
86891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86892       };
86893     } catch (...) {
86894       {
86895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86896       };
86897     }
86898   }
86899
86900   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86901   return jresult;
86902 }
86903
86904
86905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86906   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86907   std::string *arg2 = 0 ;
86908
86909   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86910   if (!jarg2) {
86911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86912     return ;
86913   }
86914   std::string arg2_str(jarg2);
86915   arg2 = &arg2_str;
86916   {
86917     try {
86918       (arg1)->ApplyTheme((std::string const &)*arg2);
86919     } catch (std::out_of_range& e) {
86920       {
86921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86922       };
86923     } catch (std::exception& e) {
86924       {
86925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86926       };
86927     } catch (Dali::DaliException e) {
86928       {
86929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86930       };
86931     } catch (...) {
86932       {
86933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86934       };
86935     }
86936   }
86937
86938
86939   //argout typemap for const std::string&
86940
86941 }
86942
86943
86944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86945   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86946
86947   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86948   {
86949     try {
86950       (arg1)->ApplyDefaultTheme();
86951     } catch (std::out_of_range& e) {
86952       {
86953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86954       };
86955     } catch (std::exception& e) {
86956       {
86957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86958       };
86959     } catch (Dali::DaliException e) {
86960       {
86961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86966       };
86967     }
86968   }
86969
86970 }
86971
86972
86973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86974   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86975   std::string *arg2 = 0 ;
86976   Dali::Property::Value *arg3 = 0 ;
86977
86978   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86979   if (!jarg2) {
86980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86981     return ;
86982   }
86983   std::string arg2_str(jarg2);
86984   arg2 = &arg2_str;
86985   arg3 = (Dali::Property::Value *)jarg3;
86986   if (!arg3) {
86987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86988     return ;
86989   }
86990   {
86991     try {
86992       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86993     } catch (std::out_of_range& e) {
86994       {
86995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86996       };
86997     } catch (std::exception& e) {
86998       {
86999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87000       };
87001     } catch (Dali::DaliException e) {
87002       {
87003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87004       };
87005     } catch (...) {
87006       {
87007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87008       };
87009     }
87010   }
87011
87012
87013   //argout typemap for const std::string&
87014
87015 }
87016
87017
87018 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87019   unsigned int jresult ;
87020   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87021   std::string *arg2 = 0 ;
87022   Dali::Property::Value *arg3 = 0 ;
87023   bool result;
87024
87025   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87026   if (!jarg2) {
87027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87028     return 0;
87029   }
87030   std::string arg2_str(jarg2);
87031   arg2 = &arg2_str;
87032   arg3 = (Dali::Property::Value *)jarg3;
87033   if (!arg3) {
87034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87035     return 0;
87036   }
87037   {
87038     try {
87039       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87040     } catch (std::out_of_range& e) {
87041       {
87042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87043       };
87044     } catch (std::exception& e) {
87045       {
87046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87047       };
87048     } catch (Dali::DaliException e) {
87049       {
87050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87051       };
87052     } catch (...) {
87053       {
87054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87055       };
87056     }
87057   }
87058
87059   jresult = result;
87060
87061   //argout typemap for const std::string&
87062
87063   return jresult;
87064 }
87065
87066
87067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87068   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87069   Dali::Toolkit::Control arg2 ;
87070   std::string *arg3 = 0 ;
87071   std::string *arg4 = 0 ;
87072   Dali::Toolkit::Control *argp2 ;
87073
87074   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87075   argp2 = (Dali::Toolkit::Control *)jarg2;
87076   if (!argp2) {
87077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87078     return ;
87079   }
87080   arg2 = *argp2;
87081   if (!jarg3) {
87082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87083     return ;
87084   }
87085   std::string arg3_str(jarg3);
87086   arg3 = &arg3_str;
87087   if (!jarg4) {
87088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87089     return ;
87090   }
87091   std::string arg4_str(jarg4);
87092   arg4 = &arg4_str;
87093   {
87094     try {
87095       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87096     } catch (std::out_of_range& e) {
87097       {
87098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87099       };
87100     } catch (std::exception& e) {
87101       {
87102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87103       };
87104     } catch (Dali::DaliException e) {
87105       {
87106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87107       };
87108     } catch (...) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87111       };
87112     }
87113   }
87114
87115
87116   //argout typemap for const std::string&
87117
87118
87119   //argout typemap for const std::string&
87120
87121 }
87122
87123
87124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87125   void * jresult ;
87126   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87127   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87128
87129   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87130   {
87131     try {
87132       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87133     } catch (std::out_of_range& e) {
87134       {
87135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87136       };
87137     } catch (std::exception& e) {
87138       {
87139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87140       };
87141     } catch (Dali::DaliException e) {
87142       {
87143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87144       };
87145     } catch (...) {
87146       {
87147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87148       };
87149     }
87150   }
87151
87152   jresult = (void *)result;
87153   return jresult;
87154 }
87155
87156
87157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87158   int jresult ;
87159   int result;
87160
87161   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87162   jresult = (int)result;
87163   return jresult;
87164 }
87165
87166
87167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87168   int jresult ;
87169   int result;
87170
87171   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87172   jresult = (int)result;
87173   return jresult;
87174 }
87175
87176
87177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87178   int jresult ;
87179   int result;
87180
87181   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87182   jresult = (int)result;
87183   return jresult;
87184 }
87185
87186
87187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87188   int jresult ;
87189   int result;
87190
87191   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87192   jresult = (int)result;
87193   return jresult;
87194 }
87195
87196
87197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87198   int jresult ;
87199   int result;
87200
87201   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87202   jresult = (int)result;
87203   return jresult;
87204 }
87205
87206
87207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87208   int jresult ;
87209   int result;
87210
87211   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87212   jresult = (int)result;
87213   return jresult;
87214 }
87215
87216
87217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87218   int jresult ;
87219   int result;
87220
87221   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87222   jresult = (int)result;
87223   return jresult;
87224 }
87225
87226
87227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87228   int jresult ;
87229   int result;
87230
87231   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87232   jresult = (int)result;
87233   return jresult;
87234 }
87235
87236
87237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87238   int jresult ;
87239   int result;
87240
87241   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87242   jresult = (int)result;
87243   return jresult;
87244 }
87245
87246
87247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87248   int jresult ;
87249   int result;
87250
87251   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87252   jresult = (int)result;
87253   return jresult;
87254 }
87255
87256
87257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87258   int jresult ;
87259   int result;
87260
87261   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87262   jresult = (int)result;
87263   return jresult;
87264 }
87265
87266
87267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87268   int jresult ;
87269   int result;
87270
87271   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87272   jresult = (int)result;
87273   return jresult;
87274 }
87275
87276
87277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87278   int jresult ;
87279   int result;
87280
87281   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87282   jresult = (int)result;
87283   return jresult;
87284 }
87285
87286
87287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87288   int jresult ;
87289   int result;
87290
87291   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87292   jresult = (int)result;
87293   return jresult;
87294 }
87295
87296
87297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87298   int jresult ;
87299   int result;
87300
87301   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87302   jresult = (int)result;
87303   return jresult;
87304 }
87305
87306
87307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87308   void * jresult ;
87309   Dali::Toolkit::Slider::Property *result = 0 ;
87310
87311   {
87312     try {
87313       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87314     } catch (std::out_of_range& e) {
87315       {
87316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87317       };
87318     } catch (std::exception& e) {
87319       {
87320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87321       };
87322     } catch (Dali::DaliException e) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87325       };
87326     } catch (...) {
87327       {
87328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87329       };
87330     }
87331   }
87332
87333   jresult = (void *)result;
87334   return jresult;
87335 }
87336
87337
87338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87339   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87340
87341   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87342   {
87343     try {
87344       delete arg1;
87345     } catch (std::out_of_range& e) {
87346       {
87347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87348       };
87349     } catch (std::exception& e) {
87350       {
87351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87352       };
87353     } catch (Dali::DaliException e) {
87354       {
87355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87356       };
87357     } catch (...) {
87358       {
87359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87360       };
87361     }
87362   }
87363
87364 }
87365
87366
87367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87368   void * jresult ;
87369   Dali::Toolkit::Slider result;
87370
87371   {
87372     try {
87373       result = Dali::Toolkit::Slider::New();
87374     } catch (std::out_of_range& e) {
87375       {
87376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87377       };
87378     } catch (std::exception& e) {
87379       {
87380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87381       };
87382     } catch (Dali::DaliException e) {
87383       {
87384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87385       };
87386     } catch (...) {
87387       {
87388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87389       };
87390     }
87391   }
87392
87393   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87394   return jresult;
87395 }
87396
87397
87398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87399   void * jresult ;
87400   Dali::Toolkit::Slider *result = 0 ;
87401
87402   {
87403     try {
87404       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87405     } catch (std::out_of_range& e) {
87406       {
87407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87408       };
87409     } catch (std::exception& e) {
87410       {
87411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87412       };
87413     } catch (Dali::DaliException e) {
87414       {
87415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87416       };
87417     } catch (...) {
87418       {
87419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87420       };
87421     }
87422   }
87423
87424   jresult = (void *)result;
87425   return jresult;
87426 }
87427
87428
87429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87430   void * jresult ;
87431   Dali::Toolkit::Slider *arg1 = 0 ;
87432   Dali::Toolkit::Slider *result = 0 ;
87433
87434   arg1 = (Dali::Toolkit::Slider *)jarg1;
87435   if (!arg1) {
87436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87437     return 0;
87438   }
87439   {
87440     try {
87441       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87442     } catch (std::out_of_range& e) {
87443       {
87444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87445       };
87446     } catch (std::exception& e) {
87447       {
87448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87449       };
87450     } catch (Dali::DaliException e) {
87451       {
87452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87453       };
87454     } catch (...) {
87455       {
87456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87457       };
87458     }
87459   }
87460
87461   jresult = (void *)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87467   void * jresult ;
87468   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87469   Dali::Toolkit::Slider *arg2 = 0 ;
87470   Dali::Toolkit::Slider *result = 0 ;
87471
87472   arg1 = (Dali::Toolkit::Slider *)jarg1;
87473   arg2 = (Dali::Toolkit::Slider *)jarg2;
87474   if (!arg2) {
87475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87476     return 0;
87477   }
87478   {
87479     try {
87480       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87481     } catch (std::out_of_range& e) {
87482       {
87483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87484       };
87485     } catch (std::exception& e) {
87486       {
87487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87488       };
87489     } catch (Dali::DaliException e) {
87490       {
87491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87492       };
87493     } catch (...) {
87494       {
87495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87496       };
87497     }
87498   }
87499
87500   jresult = (void *)result;
87501   return jresult;
87502 }
87503
87504
87505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87506   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87507
87508   arg1 = (Dali::Toolkit::Slider *)jarg1;
87509   {
87510     try {
87511       delete arg1;
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87519       };
87520     } catch (Dali::DaliException e) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87527       };
87528     }
87529   }
87530
87531 }
87532
87533
87534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87535   void * jresult ;
87536   Dali::BaseHandle arg1 ;
87537   Dali::BaseHandle *argp1 ;
87538   Dali::Toolkit::Slider result;
87539
87540   argp1 = (Dali::BaseHandle *)jarg1;
87541   if (!argp1) {
87542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87543     return 0;
87544   }
87545   arg1 = *argp1;
87546   {
87547     try {
87548       result = Dali::Toolkit::Slider::DownCast(arg1);
87549     } catch (std::out_of_range& e) {
87550       {
87551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87552       };
87553     } catch (std::exception& e) {
87554       {
87555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87556       };
87557     } catch (Dali::DaliException e) {
87558       {
87559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87560       };
87561     } catch (...) {
87562       {
87563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87564       };
87565     }
87566   }
87567
87568   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87569   return jresult;
87570 }
87571
87572
87573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87574   void * jresult ;
87575   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87576   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87577
87578   arg1 = (Dali::Toolkit::Slider *)jarg1;
87579   {
87580     try {
87581       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87582     } catch (std::out_of_range& e) {
87583       {
87584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87585       };
87586     } catch (std::exception& e) {
87587       {
87588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87589       };
87590     } catch (Dali::DaliException e) {
87591       {
87592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87593       };
87594     } catch (...) {
87595       {
87596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87597       };
87598     }
87599   }
87600
87601   jresult = (void *)result;
87602   return jresult;
87603 }
87604
87605
87606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87607   void * jresult ;
87608   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87609   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87610
87611   arg1 = (Dali::Toolkit::Slider *)jarg1;
87612   {
87613     try {
87614       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87615     } catch (std::out_of_range& e) {
87616       {
87617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87618       };
87619     } catch (std::exception& e) {
87620       {
87621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87622       };
87623     } catch (Dali::DaliException e) {
87624       {
87625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87626       };
87627     } catch (...) {
87628       {
87629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87630       };
87631     }
87632   }
87633
87634   jresult = (void *)result;
87635   return jresult;
87636 }
87637
87638
87639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87640   void * jresult ;
87641   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87642   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87643
87644   arg1 = (Dali::Toolkit::Slider *)jarg1;
87645   {
87646     try {
87647       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87648     } catch (std::out_of_range& e) {
87649       {
87650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87651       };
87652     } catch (std::exception& e) {
87653       {
87654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87655       };
87656     } catch (Dali::DaliException e) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87659       };
87660     } catch (...) {
87661       {
87662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87663       };
87664     }
87665   }
87666
87667   jresult = (void *)result;
87668   return jresult;
87669 }
87670
87671
87672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87673   int jresult ;
87674   int result;
87675
87676   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87677   jresult = (int)result;
87678   return jresult;
87679 }
87680
87681
87682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87683   int jresult ;
87684   int result;
87685
87686   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87687   jresult = (int)result;
87688   return jresult;
87689 }
87690
87691
87692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87693   int jresult ;
87694   int result;
87695
87696   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87697   jresult = (int)result;
87698   return jresult;
87699 }
87700
87701
87702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87703   int jresult ;
87704   int result;
87705
87706   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87707   jresult = (int)result;
87708   return jresult;
87709 }
87710
87711
87712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87713   int result;
87714
87715   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87716
87717   return result;
87718 }
87719
87720
87721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87722   void * jresult ;
87723   Dali::Toolkit::VideoView::Property *result = 0 ;
87724
87725   {
87726     try {
87727       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87728     } catch (std::out_of_range& e) {
87729       {
87730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87731       };
87732     } catch (std::exception& e) {
87733       {
87734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87735       };
87736     } catch (Dali::DaliException e) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87739       };
87740     } catch (...) {
87741       {
87742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87743       };
87744     }
87745   }
87746
87747   jresult = (void *)result;
87748   return jresult;
87749 }
87750
87751
87752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87753   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87754
87755   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87756   {
87757     try {
87758       delete arg1;
87759     } catch (std::out_of_range& e) {
87760       {
87761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87762       };
87763     } catch (std::exception& e) {
87764       {
87765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87766       };
87767     } catch (Dali::DaliException e) {
87768       {
87769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87770       };
87771     } catch (...) {
87772       {
87773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87774       };
87775     }
87776   }
87777
87778 }
87779
87780
87781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87782   void * jresult ;
87783   Dali::Toolkit::VideoView result;
87784
87785   {
87786     try {
87787       result = Dali::Toolkit::VideoView::New();
87788     } catch (std::out_of_range& e) {
87789       {
87790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87791       };
87792     } catch (std::exception& e) {
87793       {
87794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87795       };
87796     } catch (Dali::DaliException e) {
87797       {
87798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87799       };
87800     } catch (...) {
87801       {
87802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87803       };
87804     }
87805   }
87806
87807   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87808   return jresult;
87809 }
87810
87811
87812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87813   void * jresult ;
87814   std::string *arg1 = 0 ;
87815   Dali::Toolkit::VideoView result;
87816
87817   if (!jarg1) {
87818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87819     return 0;
87820   }
87821   std::string arg1_str(jarg1);
87822   arg1 = &arg1_str;
87823   {
87824     try {
87825       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87826     } catch (std::out_of_range& e) {
87827       {
87828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87829       };
87830     } catch (std::exception& e) {
87831       {
87832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87833       };
87834     } catch (Dali::DaliException e) {
87835       {
87836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87837       };
87838     } catch (...) {
87839       {
87840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87841       };
87842     }
87843   }
87844
87845   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87846
87847   //argout typemap for const std::string&
87848
87849   return jresult;
87850 }
87851
87852
87853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87854   void * jresult ;
87855   Dali::Toolkit::VideoView *result = 0 ;
87856
87857   {
87858     try {
87859       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87860     } catch (std::out_of_range& e) {
87861       {
87862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87863       };
87864     } catch (std::exception& e) {
87865       {
87866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87867       };
87868     } catch (Dali::DaliException e) {
87869       {
87870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87871       };
87872     } catch (...) {
87873       {
87874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87875       };
87876     }
87877   }
87878
87879   jresult = (void *)result;
87880   return jresult;
87881 }
87882
87883
87884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87885   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87886
87887   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87888   {
87889     try {
87890       delete arg1;
87891     } catch (std::out_of_range& e) {
87892       {
87893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87894       };
87895     } catch (std::exception& e) {
87896       {
87897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87898       };
87899     } catch (Dali::DaliException e) {
87900       {
87901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87902       };
87903     } catch (...) {
87904       {
87905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87906       };
87907     }
87908   }
87909
87910 }
87911
87912
87913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87914   void * jresult ;
87915   Dali::Toolkit::VideoView *arg1 = 0 ;
87916   Dali::Toolkit::VideoView *result = 0 ;
87917
87918   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87919   if (!arg1) {
87920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87921     return 0;
87922   }
87923   {
87924     try {
87925       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87926     } catch (std::out_of_range& e) {
87927       {
87928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87929       };
87930     } catch (std::exception& e) {
87931       {
87932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87933       };
87934     } catch (Dali::DaliException e) {
87935       {
87936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87937       };
87938     } catch (...) {
87939       {
87940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87941       };
87942     }
87943   }
87944
87945   jresult = (void *)result;
87946   return jresult;
87947 }
87948
87949
87950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87951   void * jresult ;
87952   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87953   Dali::Toolkit::VideoView *arg2 = 0 ;
87954   Dali::Toolkit::VideoView *result = 0 ;
87955
87956   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87957   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87958   if (!arg2) {
87959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87960     return 0;
87961   }
87962   {
87963     try {
87964       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87965     } catch (std::out_of_range& e) {
87966       {
87967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87968       };
87969     } catch (std::exception& e) {
87970       {
87971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87972       };
87973     } catch (Dali::DaliException e) {
87974       {
87975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87976       };
87977     } catch (...) {
87978       {
87979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87980       };
87981     }
87982   }
87983
87984   jresult = (void *)result;
87985   return jresult;
87986 }
87987
87988
87989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87990   void * jresult ;
87991   Dali::BaseHandle arg1 ;
87992   Dali::BaseHandle *argp1 ;
87993   Dali::Toolkit::VideoView result;
87994
87995   argp1 = (Dali::BaseHandle *)jarg1;
87996   if (!argp1) {
87997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87998     return 0;
87999   }
88000   arg1 = *argp1;
88001   {
88002     try {
88003       result = Dali::Toolkit::VideoView::DownCast(arg1);
88004     } catch (std::out_of_range& e) {
88005       {
88006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88007       };
88008     } catch (std::exception& e) {
88009       {
88010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88011       };
88012     } catch (Dali::DaliException e) {
88013       {
88014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88015       };
88016     } catch (...) {
88017       {
88018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88019       };
88020     }
88021   }
88022
88023   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88024   return jresult;
88025 }
88026
88027
88028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88029   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88030
88031   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88032   {
88033     try {
88034       (arg1)->Play();
88035     } catch (std::out_of_range& e) {
88036       {
88037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88038       };
88039     } catch (std::exception& e) {
88040       {
88041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88042       };
88043     } catch (Dali::DaliException e) {
88044       {
88045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88046       };
88047     } catch (...) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88050       };
88051     }
88052   }
88053
88054 }
88055
88056
88057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88058   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88059
88060   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88061   {
88062     try {
88063       (arg1)->Pause();
88064     } catch (std::out_of_range& e) {
88065       {
88066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88067       };
88068     } catch (std::exception& e) {
88069       {
88070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88071       };
88072     } catch (Dali::DaliException e) {
88073       {
88074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88075       };
88076     } catch (...) {
88077       {
88078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88079       };
88080     }
88081   }
88082
88083 }
88084
88085
88086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88087   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88088
88089   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88090   {
88091     try {
88092       (arg1)->Stop();
88093     } catch (std::out_of_range& e) {
88094       {
88095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88096       };
88097     } catch (std::exception& e) {
88098       {
88099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88100       };
88101     } catch (Dali::DaliException e) {
88102       {
88103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88104       };
88105     } catch (...) {
88106       {
88107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88108       };
88109     }
88110   }
88111
88112 }
88113
88114
88115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88116   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88117   int arg2 ;
88118
88119   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88120   arg2 = (int)jarg2;
88121   {
88122     try {
88123       (arg1)->Forward(arg2);
88124     } catch (std::out_of_range& e) {
88125       {
88126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88127       };
88128     } catch (std::exception& e) {
88129       {
88130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88131       };
88132     } catch (Dali::DaliException e) {
88133       {
88134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88135       };
88136     } catch (...) {
88137       {
88138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88139       };
88140     }
88141   }
88142
88143 }
88144
88145
88146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88147   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88148   int arg2 ;
88149
88150   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88151   arg2 = (int)jarg2;
88152   {
88153     try {
88154       (arg1)->Backward(arg2);
88155     } catch (std::out_of_range& e) {
88156       {
88157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88158       };
88159     } catch (std::exception& e) {
88160       {
88161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88162       };
88163     } catch (Dali::DaliException e) {
88164       {
88165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88166       };
88167     } catch (...) {
88168       {
88169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88170       };
88171     }
88172   }
88173
88174 }
88175
88176
88177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88178   void * jresult ;
88179   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88180   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88181
88182   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88183   {
88184     try {
88185       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88186     } catch (std::out_of_range& e) {
88187       {
88188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88189       };
88190     } catch (std::exception& e) {
88191       {
88192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88193       };
88194     } catch (Dali::DaliException e) {
88195       {
88196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88197       };
88198     } catch (...) {
88199       {
88200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88201       };
88202     }
88203   }
88204
88205   jresult = (void *)result;
88206   return jresult;
88207 }
88208
88209
88210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88211   int jresult ;
88212   int result;
88213
88214   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88215   jresult = (int)result;
88216   return jresult;
88217 }
88218
88219
88220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88221   int jresult ;
88222   int result;
88223
88224   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88225   jresult = (int)result;
88226   return jresult;
88227 }
88228
88229
88230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88231   int jresult ;
88232   int result;
88233
88234   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88235   jresult = (int)result;
88236   return jresult;
88237 }
88238
88239
88240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88241   int jresult ;
88242   int result;
88243
88244   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88245   jresult = (int)result;
88246   return jresult;
88247 }
88248
88249
88250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88251   int jresult ;
88252   int result;
88253
88254   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88255   jresult = (int)result;
88256   return jresult;
88257 }
88258
88259
88260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88261   int jresult ;
88262   int result;
88263
88264   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88265   jresult = (int)result;
88266   return jresult;
88267 }
88268
88269
88270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88271   int jresult ;
88272   int result;
88273
88274   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88275   jresult = (int)result;
88276   return jresult;
88277 }
88278
88279
88280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88281   int jresult ;
88282   int result;
88283
88284   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88285   jresult = (int)result;
88286   return jresult;
88287 }
88288
88289
88290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88291   int jresult ;
88292   int result;
88293
88294   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88295   jresult = (int)result;
88296   return jresult;
88297 }
88298
88299
88300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88301   int jresult ;
88302   int result;
88303
88304   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88305   jresult = (int)result;
88306   return jresult;
88307 }
88308
88309
88310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88311   int jresult ;
88312   int result;
88313
88314   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88315   jresult = (int)result;
88316   return jresult;
88317 }
88318
88319
88320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88321   int jresult ;
88322   int result;
88323
88324   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88325   jresult = (int)result;
88326   return jresult;
88327 }
88328
88329
88330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88331   int jresult ;
88332   int result;
88333
88334   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88335   jresult = (int)result;
88336   return jresult;
88337 }
88338
88339
88340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88341   int jresult ;
88342   int result;
88343
88344   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88345   jresult = (int)result;
88346   return jresult;
88347 }
88348
88349
88350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88351   int jresult ;
88352   int result;
88353
88354   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88355   jresult = (int)result;
88356   return jresult;
88357 }
88358
88359
88360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88361   int jresult ;
88362   int result;
88363
88364   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88365   jresult = (int)result;
88366   return jresult;
88367 }
88368
88369
88370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88371   int jresult ;
88372   int result;
88373
88374   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88375   jresult = (int)result;
88376   return jresult;
88377 }
88378
88379
88380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88381   int jresult ;
88382   int result;
88383
88384   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88385   jresult = (int)result;
88386   return jresult;
88387 }
88388
88389
88390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88391   int jresult ;
88392   int result;
88393
88394   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88395   jresult = (int)result;
88396   return jresult;
88397 }
88398
88399
88400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88401   int jresult ;
88402   int result;
88403
88404   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88405   jresult = (int)result;
88406   return jresult;
88407 }
88408
88409
88410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88411   int jresult ;
88412   int result;
88413
88414   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88415   jresult = (int)result;
88416   return jresult;
88417 }
88418
88419
88420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88421   void * jresult ;
88422   Dali::Toolkit::Popup::Property *result = 0 ;
88423
88424   {
88425     try {
88426       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88427     } catch (std::out_of_range& e) {
88428       {
88429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88430       };
88431     } catch (std::exception& e) {
88432       {
88433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88434       };
88435     } catch (Dali::DaliException e) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88438       };
88439     } catch (...) {
88440       {
88441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88442       };
88443     }
88444   }
88445
88446   jresult = (void *)result;
88447   return jresult;
88448 }
88449
88450
88451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88452   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88453
88454   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88455   {
88456     try {
88457       delete arg1;
88458     } catch (std::out_of_range& e) {
88459       {
88460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88461       };
88462     } catch (std::exception& e) {
88463       {
88464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88465       };
88466     } catch (Dali::DaliException e) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88469       };
88470     } catch (...) {
88471       {
88472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88473       };
88474     }
88475   }
88476
88477 }
88478
88479
88480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88481   void * jresult ;
88482   Dali::Toolkit::Popup *result = 0 ;
88483
88484   {
88485     try {
88486       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88487     } catch (std::out_of_range& e) {
88488       {
88489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88490       };
88491     } catch (std::exception& e) {
88492       {
88493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (Dali::DaliException e) {
88496       {
88497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88498       };
88499     } catch (...) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88502       };
88503     }
88504   }
88505
88506   jresult = (void *)result;
88507   return jresult;
88508 }
88509
88510
88511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88512   void * jresult ;
88513   Dali::Toolkit::Popup result;
88514
88515   {
88516     try {
88517       result = Dali::Toolkit::Popup::New();
88518     } catch (std::out_of_range& e) {
88519       {
88520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88521       };
88522     } catch (std::exception& e) {
88523       {
88524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88525       };
88526     } catch (Dali::DaliException e) {
88527       {
88528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88529       };
88530     } catch (...) {
88531       {
88532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88533       };
88534     }
88535   }
88536
88537   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88538   return jresult;
88539 }
88540
88541
88542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88543   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88544
88545   arg1 = (Dali::Toolkit::Popup *)jarg1;
88546   {
88547     try {
88548       delete arg1;
88549     } catch (std::out_of_range& e) {
88550       {
88551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88552       };
88553     } catch (std::exception& e) {
88554       {
88555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88556       };
88557     } catch (Dali::DaliException e) {
88558       {
88559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88560       };
88561     } catch (...) {
88562       {
88563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88564       };
88565     }
88566   }
88567
88568 }
88569
88570
88571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88572   void * jresult ;
88573   Dali::Toolkit::Popup *arg1 = 0 ;
88574   Dali::Toolkit::Popup *result = 0 ;
88575
88576   arg1 = (Dali::Toolkit::Popup *)jarg1;
88577   if (!arg1) {
88578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88579     return 0;
88580   }
88581   {
88582     try {
88583       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88584     } catch (std::out_of_range& e) {
88585       {
88586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88587       };
88588     } catch (std::exception& e) {
88589       {
88590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88591       };
88592     } catch (Dali::DaliException e) {
88593       {
88594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88595       };
88596     } catch (...) {
88597       {
88598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88599       };
88600     }
88601   }
88602
88603   jresult = (void *)result;
88604   return jresult;
88605 }
88606
88607
88608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88609   void * jresult ;
88610   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88611   Dali::Toolkit::Popup *arg2 = 0 ;
88612   Dali::Toolkit::Popup *result = 0 ;
88613
88614   arg1 = (Dali::Toolkit::Popup *)jarg1;
88615   arg2 = (Dali::Toolkit::Popup *)jarg2;
88616   if (!arg2) {
88617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88618     return 0;
88619   }
88620   {
88621     try {
88622       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88623     } catch (std::out_of_range& e) {
88624       {
88625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88626       };
88627     } catch (std::exception& e) {
88628       {
88629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88630       };
88631     } catch (Dali::DaliException e) {
88632       {
88633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88634       };
88635     } catch (...) {
88636       {
88637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88638       };
88639     }
88640   }
88641
88642   jresult = (void *)result;
88643   return jresult;
88644 }
88645
88646
88647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88648   void * jresult ;
88649   Dali::BaseHandle arg1 ;
88650   Dali::BaseHandle *argp1 ;
88651   Dali::Toolkit::Popup result;
88652
88653   argp1 = (Dali::BaseHandle *)jarg1;
88654   if (!argp1) {
88655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88656     return 0;
88657   }
88658   arg1 = *argp1;
88659   {
88660     try {
88661       result = Dali::Toolkit::Popup::DownCast(arg1);
88662     } catch (std::out_of_range& e) {
88663       {
88664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88665       };
88666     } catch (std::exception& e) {
88667       {
88668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88669       };
88670     } catch (Dali::DaliException e) {
88671       {
88672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88673       };
88674     } catch (...) {
88675       {
88676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88677       };
88678     }
88679   }
88680
88681   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88682   return jresult;
88683 }
88684
88685
88686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88687   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88688   Dali::Actor arg2 ;
88689   Dali::Actor *argp2 ;
88690
88691   arg1 = (Dali::Toolkit::Popup *)jarg1;
88692   argp2 = (Dali::Actor *)jarg2;
88693   if (!argp2) {
88694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88695     return ;
88696   }
88697   arg2 = *argp2;
88698   {
88699     try {
88700       (arg1)->SetTitle(arg2);
88701     } catch (std::out_of_range& e) {
88702       {
88703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88704       };
88705     } catch (std::exception& e) {
88706       {
88707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88708       };
88709     } catch (Dali::DaliException e) {
88710       {
88711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88712       };
88713     } catch (...) {
88714       {
88715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88716       };
88717     }
88718   }
88719
88720 }
88721
88722
88723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88724   void * jresult ;
88725   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88726   Dali::Actor result;
88727
88728   arg1 = (Dali::Toolkit::Popup *)jarg1;
88729   {
88730     try {
88731       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88732     } catch (std::out_of_range& e) {
88733       {
88734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88735       };
88736     } catch (std::exception& e) {
88737       {
88738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88739       };
88740     } catch (Dali::DaliException e) {
88741       {
88742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88743       };
88744     } catch (...) {
88745       {
88746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88747       };
88748     }
88749   }
88750
88751   jresult = new Dali::Actor((const Dali::Actor &)result);
88752   return jresult;
88753 }
88754
88755
88756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88757   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88758   Dali::Actor arg2 ;
88759   Dali::Actor *argp2 ;
88760
88761   arg1 = (Dali::Toolkit::Popup *)jarg1;
88762   argp2 = (Dali::Actor *)jarg2;
88763   if (!argp2) {
88764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88765     return ;
88766   }
88767   arg2 = *argp2;
88768   {
88769     try {
88770       (arg1)->SetContent(arg2);
88771     } catch (std::out_of_range& e) {
88772       {
88773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88774       };
88775     } catch (std::exception& e) {
88776       {
88777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88778       };
88779     } catch (Dali::DaliException e) {
88780       {
88781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88782       };
88783     } catch (...) {
88784       {
88785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88786       };
88787     }
88788   }
88789
88790 }
88791
88792
88793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88794   void * jresult ;
88795   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88796   Dali::Actor result;
88797
88798   arg1 = (Dali::Toolkit::Popup *)jarg1;
88799   {
88800     try {
88801       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88802     } catch (std::out_of_range& e) {
88803       {
88804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88805       };
88806     } catch (std::exception& e) {
88807       {
88808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88809       };
88810     } catch (Dali::DaliException e) {
88811       {
88812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88813       };
88814     } catch (...) {
88815       {
88816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88817       };
88818     }
88819   }
88820
88821   jresult = new Dali::Actor((const Dali::Actor &)result);
88822   return jresult;
88823 }
88824
88825
88826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88827   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88828   Dali::Actor arg2 ;
88829   Dali::Actor *argp2 ;
88830
88831   arg1 = (Dali::Toolkit::Popup *)jarg1;
88832   argp2 = (Dali::Actor *)jarg2;
88833   if (!argp2) {
88834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88835     return ;
88836   }
88837   arg2 = *argp2;
88838   {
88839     try {
88840       (arg1)->SetFooter(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 void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88864   void * jresult ;
88865   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88866   Dali::Actor result;
88867
88868   arg1 = (Dali::Toolkit::Popup *)jarg1;
88869   {
88870     try {
88871       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
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 = new Dali::Actor((const Dali::Actor &)result);
88892   return jresult;
88893 }
88894
88895
88896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88897   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88898   Dali::Toolkit::Popup::DisplayState arg2 ;
88899
88900   arg1 = (Dali::Toolkit::Popup *)jarg1;
88901   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88902   {
88903     try {
88904       (arg1)->SetDisplayState(arg2);
88905     } catch (std::out_of_range& e) {
88906       {
88907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88908       };
88909     } catch (std::exception& e) {
88910       {
88911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88912       };
88913     } catch (Dali::DaliException e) {
88914       {
88915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88916       };
88917     } catch (...) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88920       };
88921     }
88922   }
88923
88924 }
88925
88926
88927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88928   int jresult ;
88929   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88930   Dali::Toolkit::Popup::DisplayState result;
88931
88932   arg1 = (Dali::Toolkit::Popup *)jarg1;
88933   {
88934     try {
88935       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88936     } catch (std::out_of_range& e) {
88937       {
88938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88939       };
88940     } catch (std::exception& e) {
88941       {
88942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88943       };
88944     } catch (Dali::DaliException e) {
88945       {
88946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88947       };
88948     } catch (...) {
88949       {
88950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88951       };
88952     }
88953   }
88954
88955   jresult = (int)result;
88956   return jresult;
88957 }
88958
88959
88960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88961   void * jresult ;
88962   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88963   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88964
88965   arg1 = (Dali::Toolkit::Popup *)jarg1;
88966   {
88967     try {
88968       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88969     } catch (std::out_of_range& e) {
88970       {
88971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88972       };
88973     } catch (std::exception& e) {
88974       {
88975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88976       };
88977     } catch (Dali::DaliException e) {
88978       {
88979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88980       };
88981     } catch (...) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88984       };
88985     }
88986   }
88987
88988   jresult = (void *)result;
88989   return jresult;
88990 }
88991
88992
88993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88994   void * jresult ;
88995   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88996   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88997
88998   arg1 = (Dali::Toolkit::Popup *)jarg1;
88999   {
89000     try {
89001       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89002     } catch (std::out_of_range& e) {
89003       {
89004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89005       };
89006     } catch (std::exception& e) {
89007       {
89008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89009       };
89010     } catch (Dali::DaliException e) {
89011       {
89012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89013       };
89014     } catch (...) {
89015       {
89016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89017       };
89018     }
89019   }
89020
89021   jresult = (void *)result;
89022   return jresult;
89023 }
89024
89025
89026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89027   void * jresult ;
89028   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89029   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89030
89031   arg1 = (Dali::Toolkit::Popup *)jarg1;
89032   {
89033     try {
89034       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89035     } catch (std::out_of_range& e) {
89036       {
89037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89038       };
89039     } catch (std::exception& e) {
89040       {
89041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89042       };
89043     } catch (Dali::DaliException e) {
89044       {
89045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89046       };
89047     } catch (...) {
89048       {
89049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89050       };
89051     }
89052   }
89053
89054   jresult = (void *)result;
89055   return jresult;
89056 }
89057
89058
89059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89060   void * jresult ;
89061   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89062   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89063
89064   arg1 = (Dali::Toolkit::Popup *)jarg1;
89065   {
89066     try {
89067       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89068     } catch (std::out_of_range& e) {
89069       {
89070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89071       };
89072     } catch (std::exception& e) {
89073       {
89074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89075       };
89076     } catch (Dali::DaliException e) {
89077       {
89078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89079       };
89080     } catch (...) {
89081       {
89082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89083       };
89084     }
89085   }
89086
89087   jresult = (void *)result;
89088   return jresult;
89089 }
89090
89091
89092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89093   void * jresult ;
89094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89095   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89096
89097   arg1 = (Dali::Toolkit::Popup *)jarg1;
89098   {
89099     try {
89100       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89101     } catch (std::out_of_range& e) {
89102       {
89103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89104       };
89105     } catch (std::exception& e) {
89106       {
89107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89108       };
89109     } catch (Dali::DaliException e) {
89110       {
89111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89112       };
89113     } catch (...) {
89114       {
89115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89116       };
89117     }
89118   }
89119
89120   jresult = (void *)result;
89121   return jresult;
89122 }
89123
89124
89125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89126   int jresult ;
89127   int result;
89128
89129   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89130   jresult = (int)result;
89131   return jresult;
89132 }
89133
89134
89135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89136   int jresult ;
89137   int result;
89138
89139   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89140   jresult = (int)result;
89141   return jresult;
89142 }
89143
89144
89145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89146   int jresult ;
89147   int result;
89148
89149   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89150   jresult = (int)result;
89151   return jresult;
89152 }
89153
89154
89155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89156   int jresult ;
89157   int result;
89158
89159   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89160   jresult = (int)result;
89161   return jresult;
89162 }
89163
89164
89165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89166   int jresult ;
89167   int result;
89168
89169   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89170   jresult = (int)result;
89171   return jresult;
89172 }
89173
89174
89175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89176   int jresult ;
89177   int result;
89178
89179   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89180   jresult = (int)result;
89181   return jresult;
89182 }
89183
89184
89185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89186   int jresult ;
89187   int result;
89188
89189   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89190   jresult = (int)result;
89191   return jresult;
89192 }
89193
89194
89195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89196   int jresult ;
89197   int result;
89198
89199   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89200   jresult = (int)result;
89201   return jresult;
89202 }
89203
89204
89205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89206   int jresult ;
89207   int result;
89208
89209   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89210   jresult = (int)result;
89211   return jresult;
89212 }
89213
89214
89215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89216   void * jresult ;
89217   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89218
89219   {
89220     try {
89221       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89222     } catch (std::out_of_range& e) {
89223       {
89224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (std::exception& e) {
89227       {
89228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89229       };
89230     } catch (Dali::DaliException e) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89233       };
89234     } catch (...) {
89235       {
89236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89237       };
89238     }
89239   }
89240
89241   jresult = (void *)result;
89242   return jresult;
89243 }
89244
89245
89246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89247   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89248
89249   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89250   {
89251     try {
89252       delete arg1;
89253     } catch (std::out_of_range& e) {
89254       {
89255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89256       };
89257     } catch (std::exception& e) {
89258       {
89259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89260       };
89261     } catch (Dali::DaliException e) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89264       };
89265     } catch (...) {
89266       {
89267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89268       };
89269     }
89270   }
89271
89272 }
89273
89274
89275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89276   void * jresult ;
89277   Dali::Toolkit::ProgressBar result;
89278
89279   {
89280     try {
89281       result = Dali::Toolkit::ProgressBar::New();
89282     } catch (std::out_of_range& e) {
89283       {
89284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89285       };
89286     } catch (std::exception& e) {
89287       {
89288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89289       };
89290     } catch (Dali::DaliException e) {
89291       {
89292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89293       };
89294     } catch (...) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89297       };
89298     }
89299   }
89300
89301   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89302   return jresult;
89303 }
89304
89305
89306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89307   void * jresult ;
89308   Dali::Toolkit::ProgressBar *result = 0 ;
89309
89310   {
89311     try {
89312       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89313     } catch (std::out_of_range& e) {
89314       {
89315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89316       };
89317     } catch (std::exception& e) {
89318       {
89319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89320       };
89321     } catch (Dali::DaliException e) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89324       };
89325     } catch (...) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89328       };
89329     }
89330   }
89331
89332   jresult = (void *)result;
89333   return jresult;
89334 }
89335
89336
89337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89338   void * jresult ;
89339   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89340   Dali::Toolkit::ProgressBar *result = 0 ;
89341
89342   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89343   if (!arg1) {
89344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89345     return 0;
89346   }
89347   {
89348     try {
89349       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89350     } catch (std::out_of_range& e) {
89351       {
89352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89353       };
89354     } catch (std::exception& e) {
89355       {
89356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89357       };
89358     } catch (Dali::DaliException e) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89365       };
89366     }
89367   }
89368
89369   jresult = (void *)result;
89370   return jresult;
89371 }
89372
89373
89374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89375   void * jresult ;
89376   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89377   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89378   Dali::Toolkit::ProgressBar *result = 0 ;
89379
89380   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89381   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89382   if (!arg2) {
89383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89384     return 0;
89385   }
89386   {
89387     try {
89388       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89389     } catch (std::out_of_range& e) {
89390       {
89391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89392       };
89393     } catch (std::exception& e) {
89394       {
89395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89396       };
89397     } catch (Dali::DaliException e) {
89398       {
89399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89400       };
89401     } catch (...) {
89402       {
89403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89404       };
89405     }
89406   }
89407
89408   jresult = (void *)result;
89409   return jresult;
89410 }
89411
89412
89413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89414   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89415
89416   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89417   {
89418     try {
89419       delete arg1;
89420     } catch (std::out_of_range& e) {
89421       {
89422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89423       };
89424     } catch (std::exception& e) {
89425       {
89426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89427       };
89428     } catch (Dali::DaliException e) {
89429       {
89430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89431       };
89432     } catch (...) {
89433       {
89434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89435       };
89436     }
89437   }
89438
89439 }
89440
89441
89442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89443   void * jresult ;
89444   Dali::BaseHandle arg1 ;
89445   Dali::BaseHandle *argp1 ;
89446   Dali::Toolkit::ProgressBar result;
89447
89448   argp1 = (Dali::BaseHandle *)jarg1;
89449   if (!argp1) {
89450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89451     return 0;
89452   }
89453   arg1 = *argp1;
89454   {
89455     try {
89456       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
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 = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89477   return jresult;
89478 }
89479
89480
89481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89482   void * jresult ;
89483   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89484   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89485
89486   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89487   {
89488     try {
89489       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89490     } catch (std::out_of_range& e) {
89491       {
89492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89493       };
89494     } catch (std::exception& e) {
89495       {
89496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89497       };
89498     } catch (Dali::DaliException e) {
89499       {
89500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89501       };
89502     } catch (...) {
89503       {
89504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89505       };
89506     }
89507   }
89508
89509   jresult = (void *)result;
89510   return jresult;
89511 }
89512
89513
89514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89515   void * jresult ;
89516   Dali::Toolkit::GaussianBlurView *result = 0 ;
89517
89518   {
89519     try {
89520       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89521     } catch (std::out_of_range& e) {
89522       {
89523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89524       };
89525     } catch (std::exception& e) {
89526       {
89527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89528       };
89529     } catch (Dali::DaliException e) {
89530       {
89531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89532       };
89533     } catch (...) {
89534       {
89535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89536       };
89537     }
89538   }
89539
89540   jresult = (void *)result;
89541   return jresult;
89542 }
89543
89544
89545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89546   void * jresult ;
89547   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89548   Dali::Toolkit::GaussianBlurView *result = 0 ;
89549
89550   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89551   if (!arg1) {
89552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89553     return 0;
89554   }
89555   {
89556     try {
89557       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89558     } catch (std::out_of_range& e) {
89559       {
89560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89561       };
89562     } catch (std::exception& e) {
89563       {
89564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89565       };
89566     } catch (Dali::DaliException e) {
89567       {
89568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89569       };
89570     } catch (...) {
89571       {
89572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89573       };
89574     }
89575   }
89576
89577   jresult = (void *)result;
89578   return jresult;
89579 }
89580
89581
89582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89583   void * jresult ;
89584   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89585   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89586   Dali::Toolkit::GaussianBlurView *result = 0 ;
89587
89588   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89589   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89590   if (!arg2) {
89591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89592     return 0;
89593   }
89594   {
89595     try {
89596       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89597     } catch (std::out_of_range& e) {
89598       {
89599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89600       };
89601     } catch (std::exception& e) {
89602       {
89603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89604       };
89605     } catch (Dali::DaliException e) {
89606       {
89607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89608       };
89609     } catch (...) {
89610       {
89611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89612       };
89613     }
89614   }
89615
89616   jresult = (void *)result;
89617   return jresult;
89618 }
89619
89620
89621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89622   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89623
89624   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89625   {
89626     try {
89627       delete arg1;
89628     } catch (std::out_of_range& e) {
89629       {
89630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89631       };
89632     } catch (std::exception& e) {
89633       {
89634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89635       };
89636     } catch (Dali::DaliException e) {
89637       {
89638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89639       };
89640     } catch (...) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89643       };
89644     }
89645   }
89646
89647 }
89648
89649
89650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89651   void * jresult ;
89652   Dali::BaseHandle arg1 ;
89653   Dali::BaseHandle *argp1 ;
89654   Dali::Toolkit::GaussianBlurView result;
89655
89656   argp1 = (Dali::BaseHandle *)jarg1;
89657   if (!argp1) {
89658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89659     return 0;
89660   }
89661   arg1 = *argp1;
89662   {
89663     try {
89664       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89665     } catch (std::out_of_range& e) {
89666       {
89667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89668       };
89669     } catch (std::exception& e) {
89670       {
89671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89672       };
89673     } catch (Dali::DaliException e) {
89674       {
89675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89676       };
89677     } catch (...) {
89678       {
89679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89680       };
89681     }
89682   }
89683
89684   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89685   return jresult;
89686 }
89687
89688
89689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89690   void * jresult ;
89691   Dali::Toolkit::GaussianBlurView result;
89692
89693   {
89694     try {
89695       result = Dali::Toolkit::GaussianBlurView::New();
89696     } catch (std::out_of_range& e) {
89697       {
89698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89699       };
89700     } catch (std::exception& e) {
89701       {
89702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89703       };
89704     } catch (Dali::DaliException e) {
89705       {
89706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89707       };
89708     } catch (...) {
89709       {
89710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89711       };
89712     }
89713   }
89714
89715   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89716   return jresult;
89717 }
89718
89719
89720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89721   void * jresult ;
89722   unsigned int arg1 ;
89723   float arg2 ;
89724   Dali::Pixel::Format arg3 ;
89725   float arg4 ;
89726   float arg5 ;
89727   bool arg6 ;
89728   Dali::Toolkit::GaussianBlurView result;
89729
89730   arg1 = (unsigned int)jarg1;
89731   arg2 = (float)jarg2;
89732   arg3 = (Dali::Pixel::Format)jarg3;
89733   arg4 = (float)jarg4;
89734   arg5 = (float)jarg5;
89735   arg6 = jarg6 ? true : false;
89736   {
89737     try {
89738       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89739     } catch (std::out_of_range& e) {
89740       {
89741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89742       };
89743     } catch (std::exception& e) {
89744       {
89745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89746       };
89747     } catch (Dali::DaliException e) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89750       };
89751     } catch (...) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89754       };
89755     }
89756   }
89757
89758   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89759   return jresult;
89760 }
89761
89762
89763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89764   void * jresult ;
89765   unsigned int arg1 ;
89766   float arg2 ;
89767   Dali::Pixel::Format arg3 ;
89768   float arg4 ;
89769   float arg5 ;
89770   Dali::Toolkit::GaussianBlurView result;
89771
89772   arg1 = (unsigned int)jarg1;
89773   arg2 = (float)jarg2;
89774   arg3 = (Dali::Pixel::Format)jarg3;
89775   arg4 = (float)jarg4;
89776   arg5 = (float)jarg5;
89777   {
89778     try {
89779       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89780     } catch (std::out_of_range& e) {
89781       {
89782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89783       };
89784     } catch (std::exception& e) {
89785       {
89786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89787       };
89788     } catch (Dali::DaliException e) {
89789       {
89790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89791       };
89792     } catch (...) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89795       };
89796     }
89797   }
89798
89799   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89800   return jresult;
89801 }
89802
89803
89804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89805   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89806   Dali::Actor arg2 ;
89807   Dali::Actor *argp2 ;
89808
89809   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89810   argp2 = (Dali::Actor *)jarg2;
89811   if (!argp2) {
89812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89813     return ;
89814   }
89815   arg2 = *argp2;
89816   {
89817     try {
89818       (arg1)->Add(arg2);
89819     } catch (std::out_of_range& e) {
89820       {
89821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89822       };
89823     } catch (std::exception& e) {
89824       {
89825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89826       };
89827     } catch (Dali::DaliException e) {
89828       {
89829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89830       };
89831     } catch (...) {
89832       {
89833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89834       };
89835     }
89836   }
89837
89838 }
89839
89840
89841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89842   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89843   Dali::Actor arg2 ;
89844   Dali::Actor *argp2 ;
89845
89846   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89847   argp2 = (Dali::Actor *)jarg2;
89848   if (!argp2) {
89849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89850     return ;
89851   }
89852   arg2 = *argp2;
89853   {
89854     try {
89855       (arg1)->Remove(arg2);
89856     } catch (std::out_of_range& e) {
89857       {
89858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89859       };
89860     } catch (std::exception& e) {
89861       {
89862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89863       };
89864     } catch (Dali::DaliException e) {
89865       {
89866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89867       };
89868     } catch (...) {
89869       {
89870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89871       };
89872     }
89873   }
89874
89875 }
89876
89877
89878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89879   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89880
89881   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89882   {
89883     try {
89884       (arg1)->Activate();
89885     } catch (std::out_of_range& e) {
89886       {
89887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89888       };
89889     } catch (std::exception& e) {
89890       {
89891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89892       };
89893     } catch (Dali::DaliException e) {
89894       {
89895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89896       };
89897     } catch (...) {
89898       {
89899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89900       };
89901     }
89902   }
89903
89904 }
89905
89906
89907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89908   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89909
89910   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89911   {
89912     try {
89913       (arg1)->ActivateOnce();
89914     } catch (std::out_of_range& e) {
89915       {
89916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89917       };
89918     } catch (std::exception& e) {
89919       {
89920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89921       };
89922     } catch (Dali::DaliException e) {
89923       {
89924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89925       };
89926     } catch (...) {
89927       {
89928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89929       };
89930     }
89931   }
89932
89933 }
89934
89935
89936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89937   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89938
89939   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89940   {
89941     try {
89942       (arg1)->Deactivate();
89943     } catch (std::out_of_range& e) {
89944       {
89945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89946       };
89947     } catch (std::exception& e) {
89948       {
89949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89950       };
89951     } catch (Dali::DaliException e) {
89952       {
89953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89954       };
89955     } catch (...) {
89956       {
89957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89958       };
89959     }
89960   }
89961
89962 }
89963
89964
89965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89966   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89967   Dali::Image arg2 ;
89968   Dali::FrameBufferImage arg3 ;
89969   Dali::Image *argp2 ;
89970   Dali::FrameBufferImage *argp3 ;
89971
89972   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89973   argp2 = (Dali::Image *)jarg2;
89974   if (!argp2) {
89975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89976     return ;
89977   }
89978   arg2 = *argp2;
89979   argp3 = (Dali::FrameBufferImage *)jarg3;
89980   if (!argp3) {
89981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89982     return ;
89983   }
89984   arg3 = *argp3;
89985   {
89986     try {
89987       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89988     } catch (std::out_of_range& e) {
89989       {
89990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89991       };
89992     } catch (std::exception& e) {
89993       {
89994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89995       };
89996     } catch (Dali::DaliException e) {
89997       {
89998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89999       };
90000     } catch (...) {
90001       {
90002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90003       };
90004     }
90005   }
90006
90007 }
90008
90009
90010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90011   int jresult ;
90012   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90013   Dali::Property::Index result;
90014
90015   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90016   {
90017     try {
90018       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90019     } catch (std::out_of_range& e) {
90020       {
90021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90022       };
90023     } catch (std::exception& e) {
90024       {
90025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90026       };
90027     } catch (Dali::DaliException e) {
90028       {
90029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90030       };
90031     } catch (...) {
90032       {
90033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90034       };
90035     }
90036   }
90037
90038   jresult = result;
90039   return jresult;
90040 }
90041
90042
90043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90044   void * jresult ;
90045   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90046   Dali::FrameBufferImage result;
90047
90048   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90049   {
90050     try {
90051       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90052     } catch (std::out_of_range& e) {
90053       {
90054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90055       };
90056     } catch (std::exception& e) {
90057       {
90058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90059       };
90060     } catch (Dali::DaliException e) {
90061       {
90062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90063       };
90064     } catch (...) {
90065       {
90066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90067       };
90068     }
90069   }
90070
90071   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90072   return jresult;
90073 }
90074
90075
90076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90077   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90078   Dali::Vector4 *arg2 = 0 ;
90079
90080   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90081   arg2 = (Dali::Vector4 *)jarg2;
90082   if (!arg2) {
90083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90084     return ;
90085   }
90086   {
90087     try {
90088       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90089     } catch (std::out_of_range& e) {
90090       {
90091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90092       };
90093     } catch (std::exception& e) {
90094       {
90095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90096       };
90097     } catch (Dali::DaliException e) {
90098       {
90099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90100       };
90101     } catch (...) {
90102       {
90103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90104       };
90105     }
90106   }
90107
90108 }
90109
90110
90111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90112   void * jresult ;
90113   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90114   Dali::Vector4 result;
90115
90116   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90117   {
90118     try {
90119       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90120     } catch (std::out_of_range& e) {
90121       {
90122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90123       };
90124     } catch (std::exception& e) {
90125       {
90126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90127       };
90128     } catch (Dali::DaliException e) {
90129       {
90130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90135       };
90136     }
90137   }
90138
90139   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90140   return jresult;
90141 }
90142
90143
90144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90145   void * jresult ;
90146   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90147   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90148
90149   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90150   {
90151     try {
90152       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90153     } catch (std::out_of_range& e) {
90154       {
90155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90156       };
90157     } catch (std::exception& e) {
90158       {
90159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90160       };
90161     } catch (Dali::DaliException e) {
90162       {
90163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90164       };
90165     } catch (...) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90168       };
90169     }
90170   }
90171
90172   jresult = (void *)result;
90173   return jresult;
90174 }
90175
90176
90177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90178   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90179
90180   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90181   {
90182     try {
90183       delete arg1;
90184     } catch (std::out_of_range& e) {
90185       {
90186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90187       };
90188     } catch (std::exception& e) {
90189       {
90190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90191       };
90192     } catch (Dali::DaliException e) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90195       };
90196     } catch (...) {
90197       {
90198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90199       };
90200     }
90201   }
90202
90203 }
90204
90205
90206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90207   unsigned int jresult ;
90208   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90209   unsigned int result;
90210
90211   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90212   {
90213     try {
90214       result = (unsigned int)(arg1)->GetNumberOfPages();
90215     } catch (std::out_of_range& e) {
90216       {
90217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90218       };
90219     } catch (std::exception& e) {
90220       {
90221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90222       };
90223     } catch (Dali::DaliException e) {
90224       {
90225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90226       };
90227     } catch (...) {
90228       {
90229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90230       };
90231     }
90232   }
90233
90234   jresult = result;
90235   return jresult;
90236 }
90237
90238
90239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90240   void * jresult ;
90241   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90242   unsigned int arg2 ;
90243   Dali::Texture result;
90244
90245   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90246   arg2 = (unsigned int)jarg2;
90247   {
90248     try {
90249       result = (arg1)->NewPage(arg2);
90250     } catch (std::out_of_range& e) {
90251       {
90252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90253       };
90254     } catch (std::exception& e) {
90255       {
90256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90257       };
90258     } catch (Dali::DaliException e) {
90259       {
90260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90261       };
90262     } catch (...) {
90263       {
90264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90265       };
90266     }
90267   }
90268
90269   jresult = new Dali::Texture((const Dali::Texture &)result);
90270   return jresult;
90271 }
90272
90273
90274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90275   int jresult ;
90276   int result;
90277
90278   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90279   jresult = (int)result;
90280   return jresult;
90281 }
90282
90283
90284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90285   int jresult ;
90286   int result;
90287
90288   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90289   jresult = (int)result;
90290   return jresult;
90291 }
90292
90293
90294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90295   int jresult ;
90296   int result;
90297
90298   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90299   jresult = (int)result;
90300   return jresult;
90301 }
90302
90303
90304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90305   void * jresult ;
90306   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90307
90308   {
90309     try {
90310       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90311     } catch (std::out_of_range& e) {
90312       {
90313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90314       };
90315     } catch (std::exception& e) {
90316       {
90317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90318       };
90319     } catch (Dali::DaliException e) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90322       };
90323     } catch (...) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90326       };
90327     }
90328   }
90329
90330   jresult = (void *)result;
90331   return jresult;
90332 }
90333
90334
90335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90336   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90337
90338   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90339   {
90340     try {
90341       delete arg1;
90342     } catch (std::out_of_range& e) {
90343       {
90344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (std::exception& e) {
90347       {
90348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90349       };
90350     } catch (Dali::DaliException e) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90357       };
90358     }
90359   }
90360
90361 }
90362
90363
90364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90365   void * jresult ;
90366   Dali::Toolkit::PageTurnView *result = 0 ;
90367
90368   {
90369     try {
90370       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90371     } catch (std::out_of_range& e) {
90372       {
90373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90374       };
90375     } catch (std::exception& e) {
90376       {
90377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90378       };
90379     } catch (Dali::DaliException e) {
90380       {
90381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90382       };
90383     } catch (...) {
90384       {
90385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90386       };
90387     }
90388   }
90389
90390   jresult = (void *)result;
90391   return jresult;
90392 }
90393
90394
90395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90396   void * jresult ;
90397   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90398   Dali::Toolkit::PageTurnView *result = 0 ;
90399
90400   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90401   if (!arg1) {
90402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90403     return 0;
90404   }
90405   {
90406     try {
90407       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90408     } catch (std::out_of_range& e) {
90409       {
90410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90411       };
90412     } catch (std::exception& e) {
90413       {
90414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90415       };
90416     } catch (Dali::DaliException e) {
90417       {
90418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90419       };
90420     } catch (...) {
90421       {
90422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90423       };
90424     }
90425   }
90426
90427   jresult = (void *)result;
90428   return jresult;
90429 }
90430
90431
90432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90433   void * jresult ;
90434   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90435   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90436   Dali::Toolkit::PageTurnView *result = 0 ;
90437
90438   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90439   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90440   if (!arg2) {
90441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90442     return 0;
90443   }
90444   {
90445     try {
90446       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90447     } catch (std::out_of_range& e) {
90448       {
90449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90450       };
90451     } catch (std::exception& e) {
90452       {
90453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90454       };
90455     } catch (Dali::DaliException e) {
90456       {
90457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90458       };
90459     } catch (...) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90462       };
90463     }
90464   }
90465
90466   jresult = (void *)result;
90467   return jresult;
90468 }
90469
90470
90471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90472   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90473
90474   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90475   {
90476     try {
90477       delete arg1;
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90493       };
90494     }
90495   }
90496
90497 }
90498
90499
90500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90501   void * jresult ;
90502   Dali::BaseHandle arg1 ;
90503   Dali::BaseHandle *argp1 ;
90504   Dali::Toolkit::PageTurnView result;
90505
90506   argp1 = (Dali::BaseHandle *)jarg1;
90507   if (!argp1) {
90508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90509     return 0;
90510   }
90511   arg1 = *argp1;
90512   {
90513     try {
90514       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90515     } catch (std::out_of_range& e) {
90516       {
90517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90518       };
90519     } catch (std::exception& e) {
90520       {
90521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90522       };
90523     } catch (Dali::DaliException e) {
90524       {
90525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90526       };
90527     } catch (...) {
90528       {
90529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90530       };
90531     }
90532   }
90533
90534   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90535   return jresult;
90536 }
90537
90538
90539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90540   void * jresult ;
90541   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90542   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90543
90544   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90545   {
90546     try {
90547       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90548     } catch (std::out_of_range& e) {
90549       {
90550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90551       };
90552     } catch (std::exception& e) {
90553       {
90554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90555       };
90556     } catch (Dali::DaliException e) {
90557       {
90558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90559       };
90560     } catch (...) {
90561       {
90562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90563       };
90564     }
90565   }
90566
90567   jresult = (void *)result;
90568   return jresult;
90569 }
90570
90571
90572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90573   void * jresult ;
90574   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90575   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90576
90577   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90578   {
90579     try {
90580       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90581     } catch (std::out_of_range& e) {
90582       {
90583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90584       };
90585     } catch (std::exception& e) {
90586       {
90587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90588       };
90589     } catch (Dali::DaliException e) {
90590       {
90591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90592       };
90593     } catch (...) {
90594       {
90595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90596       };
90597     }
90598   }
90599
90600   jresult = (void *)result;
90601   return jresult;
90602 }
90603
90604
90605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90606   void * jresult ;
90607   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90608   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90609
90610   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90611   {
90612     try {
90613       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
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_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90639   void * jresult ;
90640   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90641   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90642
90643   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90644   {
90645     try {
90646       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90647     } catch (std::out_of_range& e) {
90648       {
90649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90650       };
90651     } catch (std::exception& e) {
90652       {
90653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90654       };
90655     } catch (Dali::DaliException e) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90658       };
90659     } catch (...) {
90660       {
90661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90662       };
90663     }
90664   }
90665
90666   jresult = (void *)result;
90667   return jresult;
90668 }
90669
90670
90671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90672   void * jresult ;
90673   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90674
90675   {
90676     try {
90677       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90685       };
90686     } catch (Dali::DaliException e) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90693       };
90694     }
90695   }
90696
90697   jresult = (void *)result;
90698   return jresult;
90699 }
90700
90701
90702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90703   void * jresult ;
90704   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90705   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90706
90707   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90708   if (!arg1) {
90709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90710     return 0;
90711   }
90712   {
90713     try {
90714       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90715     } catch (std::out_of_range& e) {
90716       {
90717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90718       };
90719     } catch (std::exception& e) {
90720       {
90721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90722       };
90723     } catch (Dali::DaliException e) {
90724       {
90725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90726       };
90727     } catch (...) {
90728       {
90729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90730       };
90731     }
90732   }
90733
90734   jresult = (void *)result;
90735   return jresult;
90736 }
90737
90738
90739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90740   void * jresult ;
90741   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90742   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90743   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90744
90745   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90746   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90747   if (!arg2) {
90748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90749     return 0;
90750   }
90751   {
90752     try {
90753       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90754     } catch (std::out_of_range& e) {
90755       {
90756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90757       };
90758     } catch (std::exception& e) {
90759       {
90760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90761       };
90762     } catch (Dali::DaliException e) {
90763       {
90764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90765       };
90766     } catch (...) {
90767       {
90768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90769       };
90770     }
90771   }
90772
90773   jresult = (void *)result;
90774   return jresult;
90775 }
90776
90777
90778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90779   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90780
90781   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90782   {
90783     try {
90784       delete arg1;
90785     } catch (std::out_of_range& e) {
90786       {
90787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90788       };
90789     } catch (std::exception& e) {
90790       {
90791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90792       };
90793     } catch (Dali::DaliException e) {
90794       {
90795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90796       };
90797     } catch (...) {
90798       {
90799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90800       };
90801     }
90802   }
90803
90804 }
90805
90806
90807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90808   void * jresult ;
90809   Dali::Toolkit::PageFactory *arg1 = 0 ;
90810   Dali::Vector2 *arg2 = 0 ;
90811   Dali::Toolkit::PageTurnLandscapeView result;
90812
90813   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90814   if (!arg1) {
90815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90816     return 0;
90817   }
90818   arg2 = (Dali::Vector2 *)jarg2;
90819   if (!arg2) {
90820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90821     return 0;
90822   }
90823   {
90824     try {
90825       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90826     } catch (std::out_of_range& e) {
90827       {
90828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90829       };
90830     } catch (std::exception& e) {
90831       {
90832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90833       };
90834     } catch (Dali::DaliException e) {
90835       {
90836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90837       };
90838     } catch (...) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90841       };
90842     }
90843   }
90844
90845   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90846   return jresult;
90847 }
90848
90849
90850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90851   void * jresult ;
90852   Dali::BaseHandle arg1 ;
90853   Dali::BaseHandle *argp1 ;
90854   Dali::Toolkit::PageTurnLandscapeView result;
90855
90856   argp1 = (Dali::BaseHandle *)jarg1;
90857   if (!argp1) {
90858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90859     return 0;
90860   }
90861   arg1 = *argp1;
90862   {
90863     try {
90864       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90865     } catch (std::out_of_range& e) {
90866       {
90867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90868       };
90869     } catch (std::exception& e) {
90870       {
90871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90872       };
90873     } catch (Dali::DaliException e) {
90874       {
90875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90876       };
90877     } catch (...) {
90878       {
90879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90880       };
90881     }
90882   }
90883
90884   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90885   return jresult;
90886 }
90887
90888
90889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90890   void * jresult ;
90891   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90892
90893   {
90894     try {
90895       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90896     } catch (std::out_of_range& e) {
90897       {
90898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90899       };
90900     } catch (std::exception& e) {
90901       {
90902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90903       };
90904     } catch (Dali::DaliException e) {
90905       {
90906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90907       };
90908     } catch (...) {
90909       {
90910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90911       };
90912     }
90913   }
90914
90915   jresult = (void *)result;
90916   return jresult;
90917 }
90918
90919
90920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90921   void * jresult ;
90922   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90923   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90924
90925   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90926   if (!arg1) {
90927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90928     return 0;
90929   }
90930   {
90931     try {
90932       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90933     } catch (std::out_of_range& e) {
90934       {
90935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90936       };
90937     } catch (std::exception& e) {
90938       {
90939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90940       };
90941     } catch (Dali::DaliException e) {
90942       {
90943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90944       };
90945     } catch (...) {
90946       {
90947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90948       };
90949     }
90950   }
90951
90952   jresult = (void *)result;
90953   return jresult;
90954 }
90955
90956
90957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90958   void * jresult ;
90959   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90960   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90961   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90962
90963   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90964   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90965   if (!arg2) {
90966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90967     return 0;
90968   }
90969   {
90970     try {
90971       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90972     } catch (std::out_of_range& e) {
90973       {
90974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90975       };
90976     } catch (std::exception& e) {
90977       {
90978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (Dali::DaliException e) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90983       };
90984     } catch (...) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90987       };
90988     }
90989   }
90990
90991   jresult = (void *)result;
90992   return jresult;
90993 }
90994
90995
90996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90997   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90998
90999   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91000   {
91001     try {
91002       delete arg1;
91003     } catch (std::out_of_range& e) {
91004       {
91005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91006       };
91007     } catch (std::exception& e) {
91008       {
91009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91010       };
91011     } catch (Dali::DaliException e) {
91012       {
91013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91014       };
91015     } catch (...) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91018       };
91019     }
91020   }
91021
91022 }
91023
91024
91025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91026   void * jresult ;
91027   Dali::Toolkit::PageFactory *arg1 = 0 ;
91028   Dali::Vector2 *arg2 = 0 ;
91029   Dali::Toolkit::PageTurnPortraitView result;
91030
91031   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91032   if (!arg1) {
91033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91034     return 0;
91035   }
91036   arg2 = (Dali::Vector2 *)jarg2;
91037   if (!arg2) {
91038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91039     return 0;
91040   }
91041   {
91042     try {
91043       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91044     } catch (std::out_of_range& e) {
91045       {
91046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91047       };
91048     } catch (std::exception& e) {
91049       {
91050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91051       };
91052     } catch (Dali::DaliException e) {
91053       {
91054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91055       };
91056     } catch (...) {
91057       {
91058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91059       };
91060     }
91061   }
91062
91063   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91064   return jresult;
91065 }
91066
91067
91068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91069   void * jresult ;
91070   Dali::BaseHandle arg1 ;
91071   Dali::BaseHandle *argp1 ;
91072   Dali::Toolkit::PageTurnPortraitView result;
91073
91074   argp1 = (Dali::BaseHandle *)jarg1;
91075   if (!argp1) {
91076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91077     return 0;
91078   }
91079   arg1 = *argp1;
91080   {
91081     try {
91082       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91083     } catch (std::out_of_range& e) {
91084       {
91085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91086       };
91087     } catch (std::exception& e) {
91088       {
91089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91090       };
91091     } catch (Dali::DaliException e) {
91092       {
91093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91094       };
91095     } catch (...) {
91096       {
91097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91098       };
91099     }
91100   }
91101
91102   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91103   return jresult;
91104 }
91105
91106
91107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91108   int jresult ;
91109   int result;
91110
91111   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91112   jresult = (int)result;
91113   return jresult;
91114 }
91115
91116
91117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91118   int jresult ;
91119   int result;
91120
91121   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91122   jresult = (int)result;
91123   return jresult;
91124 }
91125
91126
91127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91128   int jresult ;
91129   int result;
91130
91131   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91132   jresult = (int)result;
91133   return jresult;
91134 }
91135
91136
91137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91138   void * jresult ;
91139   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91140
91141   {
91142     try {
91143       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91144     } catch (std::out_of_range& e) {
91145       {
91146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91147       };
91148     } catch (std::exception& e) {
91149       {
91150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (Dali::DaliException e) {
91153       {
91154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91155       };
91156     } catch (...) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91159       };
91160     }
91161   }
91162
91163   jresult = (void *)result;
91164   return jresult;
91165 }
91166
91167
91168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91169   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91170
91171   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91172   {
91173     try {
91174       delete arg1;
91175     } catch (std::out_of_range& e) {
91176       {
91177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91178       };
91179     } catch (std::exception& e) {
91180       {
91181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91182       };
91183     } catch (Dali::DaliException e) {
91184       {
91185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91186       };
91187     } catch (...) {
91188       {
91189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91190       };
91191     }
91192   }
91193
91194 }
91195
91196
91197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91198   void * jresult ;
91199   Dali::Toolkit::ToggleButton *result = 0 ;
91200
91201   {
91202     try {
91203       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91204     } catch (std::out_of_range& e) {
91205       {
91206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91207       };
91208     } catch (std::exception& e) {
91209       {
91210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91211       };
91212     } catch (Dali::DaliException e) {
91213       {
91214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91215       };
91216     } catch (...) {
91217       {
91218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91219       };
91220     }
91221   }
91222
91223   jresult = (void *)result;
91224   return jresult;
91225 }
91226
91227
91228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91229   void * jresult ;
91230   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91231   Dali::Toolkit::ToggleButton *result = 0 ;
91232
91233   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91234   if (!arg1) {
91235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91236     return 0;
91237   }
91238   {
91239     try {
91240       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91241     } catch (std::out_of_range& e) {
91242       {
91243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91244       };
91245     } catch (std::exception& e) {
91246       {
91247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91248       };
91249     } catch (Dali::DaliException e) {
91250       {
91251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91252       };
91253     } catch (...) {
91254       {
91255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91256       };
91257     }
91258   }
91259
91260   jresult = (void *)result;
91261   return jresult;
91262 }
91263
91264
91265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91266   void * jresult ;
91267   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91268   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91269   Dali::Toolkit::ToggleButton *result = 0 ;
91270
91271   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91272   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91273   if (!arg2) {
91274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91275     return 0;
91276   }
91277   {
91278     try {
91279       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91280     } catch (std::out_of_range& e) {
91281       {
91282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (std::exception& e) {
91285       {
91286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91287       };
91288     } catch (Dali::DaliException e) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91291       };
91292     } catch (...) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91295       };
91296     }
91297   }
91298
91299   jresult = (void *)result;
91300   return jresult;
91301 }
91302
91303
91304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91305   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91306
91307   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91308   {
91309     try {
91310       delete arg1;
91311     } catch (std::out_of_range& e) {
91312       {
91313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91314       };
91315     } catch (std::exception& e) {
91316       {
91317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91318       };
91319     } catch (Dali::DaliException e) {
91320       {
91321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91322       };
91323     } catch (...) {
91324       {
91325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91326       };
91327     }
91328   }
91329
91330 }
91331
91332
91333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91334   void * jresult ;
91335   Dali::Toolkit::ToggleButton result;
91336
91337   {
91338     try {
91339       result = Dali::Toolkit::ToggleButton::New();
91340     } catch (std::out_of_range& e) {
91341       {
91342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91343       };
91344     } catch (std::exception& e) {
91345       {
91346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91347       };
91348     } catch (Dali::DaliException e) {
91349       {
91350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91351       };
91352     } catch (...) {
91353       {
91354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91355       };
91356     }
91357   }
91358
91359   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91360   return jresult;
91361 }
91362
91363
91364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91365   void * jresult ;
91366   Dali::BaseHandle arg1 ;
91367   Dali::BaseHandle *argp1 ;
91368   Dali::Toolkit::ToggleButton result;
91369
91370   argp1 = (Dali::BaseHandle *)jarg1;
91371   if (!argp1) {
91372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91373     return 0;
91374   }
91375   arg1 = *argp1;
91376   {
91377     try {
91378       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91379     } catch (std::out_of_range& e) {
91380       {
91381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91382       };
91383     } catch (std::exception& e) {
91384       {
91385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91386       };
91387     } catch (Dali::DaliException e) {
91388       {
91389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91390       };
91391     } catch (...) {
91392       {
91393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91394       };
91395     }
91396   }
91397
91398   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91399   return jresult;
91400 }
91401
91402
91403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91404   void * jresult ;
91405   Dali::Toolkit::Visual::Base *result = 0 ;
91406
91407   {
91408     try {
91409       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91410     } catch (std::out_of_range& e) {
91411       {
91412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91413       };
91414     } catch (std::exception& e) {
91415       {
91416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91417       };
91418     } catch (Dali::DaliException e) {
91419       {
91420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91421       };
91422     } catch (...) {
91423       {
91424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91425       };
91426     }
91427   }
91428
91429   jresult = (void *)result;
91430   return jresult;
91431 }
91432
91433
91434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91435   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91436
91437   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91438   {
91439     try {
91440       delete arg1;
91441     } catch (std::out_of_range& e) {
91442       {
91443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91444       };
91445     } catch (std::exception& e) {
91446       {
91447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91448       };
91449     } catch (Dali::DaliException e) {
91450       {
91451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91452       };
91453     } catch (...) {
91454       {
91455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91456       };
91457     }
91458   }
91459
91460 }
91461
91462
91463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91464   void * jresult ;
91465   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91466   Dali::Toolkit::Visual::Base *result = 0 ;
91467
91468   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91469   if (!arg1) {
91470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91471     return 0;
91472   }
91473   {
91474     try {
91475       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91476     } catch (std::out_of_range& e) {
91477       {
91478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91479       };
91480     } catch (std::exception& e) {
91481       {
91482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91483       };
91484     } catch (Dali::DaliException e) {
91485       {
91486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91487       };
91488     } catch (...) {
91489       {
91490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91491       };
91492     }
91493   }
91494
91495   jresult = (void *)result;
91496   return jresult;
91497 }
91498
91499
91500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91501   void * jresult ;
91502   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91503   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91504   Dali::Toolkit::Visual::Base *result = 0 ;
91505
91506   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91507   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91508   if (!arg2) {
91509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91510     return 0;
91511   }
91512   {
91513     try {
91514       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91515     } catch (std::out_of_range& e) {
91516       {
91517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91518       };
91519     } catch (std::exception& e) {
91520       {
91521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91522       };
91523     } catch (Dali::DaliException e) {
91524       {
91525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91526       };
91527     } catch (...) {
91528       {
91529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91530       };
91531     }
91532   }
91533
91534   jresult = (void *)result;
91535   return jresult;
91536 }
91537
91538
91539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91540   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91541   std::string *arg2 = 0 ;
91542
91543   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91544   if (!jarg2) {
91545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91546     return ;
91547   }
91548   std::string arg2_str(jarg2);
91549   arg2 = &arg2_str;
91550   {
91551     try {
91552       (arg1)->SetName((std::string const &)*arg2);
91553     } catch (std::out_of_range& e) {
91554       {
91555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91556       };
91557     } catch (std::exception& e) {
91558       {
91559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91560       };
91561     } catch (Dali::DaliException e) {
91562       {
91563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91564       };
91565     } catch (...) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91568       };
91569     }
91570   }
91571
91572
91573   //argout typemap for const std::string&
91574
91575 }
91576
91577
91578 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91579   char * jresult ;
91580   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91581   std::string *result = 0 ;
91582
91583   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91584   {
91585     try {
91586       result = (std::string *) &(arg1)->GetName();
91587     } catch (std::out_of_range& e) {
91588       {
91589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91590       };
91591     } catch (std::exception& e) {
91592       {
91593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91594       };
91595     } catch (Dali::DaliException e) {
91596       {
91597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91598       };
91599     } catch (...) {
91600       {
91601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91602       };
91603     }
91604   }
91605
91606   jresult = SWIG_csharp_string_callback(result->c_str());
91607   return jresult;
91608 }
91609
91610
91611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91612   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91613   Dali::Property::Map *arg2 = 0 ;
91614   Dali::Size arg3 ;
91615   Dali::Size *argp3 ;
91616
91617   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91618   arg2 = (Dali::Property::Map *)jarg2;
91619   if (!arg2) {
91620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91621     return ;
91622   }
91623   argp3 = (Dali::Size *)jarg3;
91624   if (!argp3) {
91625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91626     return ;
91627   }
91628   arg3 = *argp3;
91629   {
91630     try {
91631       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91632     } catch (std::out_of_range& e) {
91633       {
91634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91635       };
91636     } catch (std::exception& e) {
91637       {
91638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91639       };
91640     } catch (Dali::DaliException e) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91643       };
91644     } catch (...) {
91645       {
91646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91647       };
91648     }
91649   }
91650
91651 }
91652
91653
91654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91655   float jresult ;
91656   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91657   float arg2 ;
91658   float result;
91659
91660   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91661   arg2 = (float)jarg2;
91662   {
91663     try {
91664       result = (float)(arg1)->GetHeightForWidth(arg2);
91665     } catch (std::out_of_range& e) {
91666       {
91667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91668       };
91669     } catch (std::exception& e) {
91670       {
91671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91672       };
91673     } catch (Dali::DaliException e) {
91674       {
91675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91676       };
91677     } catch (...) {
91678       {
91679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91680       };
91681     }
91682   }
91683
91684   jresult = result;
91685   return jresult;
91686 }
91687
91688
91689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91690   float jresult ;
91691   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91692   float arg2 ;
91693   float result;
91694
91695   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91696   arg2 = (float)jarg2;
91697   {
91698     try {
91699       result = (float)(arg1)->GetWidthForHeight(arg2);
91700     } catch (std::out_of_range& e) {
91701       {
91702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91703       };
91704     } catch (std::exception& e) {
91705       {
91706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91707       };
91708     } catch (Dali::DaliException e) {
91709       {
91710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91711       };
91712     } catch (...) {
91713       {
91714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91715       };
91716     }
91717   }
91718
91719   jresult = result;
91720   return jresult;
91721 }
91722
91723
91724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91725   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91726   Dali::Vector2 *arg2 = 0 ;
91727
91728   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91729   arg2 = (Dali::Vector2 *)jarg2;
91730   if (!arg2) {
91731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91732     return ;
91733   }
91734   {
91735     try {
91736       (arg1)->GetNaturalSize(*arg2);
91737     } catch (std::out_of_range& e) {
91738       {
91739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91740       };
91741     } catch (std::exception& e) {
91742       {
91743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91744       };
91745     } catch (Dali::DaliException e) {
91746       {
91747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91748       };
91749     } catch (...) {
91750       {
91751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91752       };
91753     }
91754   }
91755
91756 }
91757
91758
91759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91760   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91761   float arg2 ;
91762
91763   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91764   arg2 = (int)jarg2;
91765   {
91766     try {
91767       (arg1)->SetDepthIndex(arg2);
91768     } catch (std::out_of_range& e) {
91769       {
91770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91771       };
91772     } catch (std::exception& e) {
91773       {
91774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91775       };
91776     } catch (Dali::DaliException e) {
91777       {
91778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91779       };
91780     } catch (...) {
91781       {
91782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91783       };
91784     }
91785   }
91786
91787 }
91788
91789
91790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91791   int jresult ;
91792   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91793   int result;
91794
91795   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91796   {
91797     try {
91798       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91799     } catch (std::out_of_range& e) {
91800       {
91801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91802       };
91803     } catch (std::exception& e) {
91804       {
91805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91806       };
91807     } catch (Dali::DaliException e) {
91808       {
91809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91810       };
91811     } catch (...) {
91812       {
91813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91814       };
91815     }
91816   }
91817
91818   jresult = result;
91819   return jresult;
91820 }
91821
91822
91823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91824   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91825   Dali::Property::Map *arg2 = 0 ;
91826
91827   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91828   arg2 = (Dali::Property::Map *)jarg2;
91829   if (!arg2) {
91830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91831     return ;
91832   }
91833   {
91834     try {
91835       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91836     } catch (std::out_of_range& e) {
91837       {
91838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91839       };
91840     } catch (std::exception& e) {
91841       {
91842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91843       };
91844     } catch (Dali::DaliException e) {
91845       {
91846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91847       };
91848     } catch (...) {
91849       {
91850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91851       };
91852     }
91853   }
91854
91855 }
91856
91857
91858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91859   void * jresult ;
91860   Dali::Toolkit::VisualFactory result;
91861
91862   {
91863     try {
91864       result = Dali::Toolkit::VisualFactory::Get();
91865     } catch (std::out_of_range& e) {
91866       {
91867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91868       };
91869     } catch (std::exception& e) {
91870       {
91871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91872       };
91873     } catch (Dali::DaliException e) {
91874       {
91875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91876       };
91877     } catch (...) {
91878       {
91879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91880       };
91881     }
91882   }
91883
91884   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91885   return jresult;
91886 }
91887
91888
91889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91890   void * jresult ;
91891   Dali::Toolkit::VisualFactory *result = 0 ;
91892
91893   {
91894     try {
91895       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91896     } catch (std::out_of_range& e) {
91897       {
91898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91899       };
91900     } catch (std::exception& e) {
91901       {
91902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91903       };
91904     } catch (Dali::DaliException e) {
91905       {
91906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91907       };
91908     } catch (...) {
91909       {
91910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91911       };
91912     }
91913   }
91914
91915   jresult = (void *)result;
91916   return jresult;
91917 }
91918
91919
91920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91921   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91922
91923   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91924   {
91925     try {
91926       delete arg1;
91927     } catch (std::out_of_range& e) {
91928       {
91929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91930       };
91931     } catch (std::exception& e) {
91932       {
91933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91934       };
91935     } catch (Dali::DaliException e) {
91936       {
91937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91938       };
91939     } catch (...) {
91940       {
91941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91942       };
91943     }
91944   }
91945
91946 }
91947
91948
91949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91950   void * jresult ;
91951   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91952   Dali::Toolkit::VisualFactory *result = 0 ;
91953
91954   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91955   if (!arg1) {
91956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91957     return 0;
91958   }
91959   {
91960     try {
91961       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91962     } catch (std::out_of_range& e) {
91963       {
91964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91965       };
91966     } catch (std::exception& e) {
91967       {
91968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91969       };
91970     } catch (Dali::DaliException e) {
91971       {
91972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91973       };
91974     } catch (...) {
91975       {
91976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91977       };
91978     }
91979   }
91980
91981   jresult = (void *)result;
91982   return jresult;
91983 }
91984
91985
91986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91987   void * jresult ;
91988   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91989   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91990   Dali::Toolkit::VisualFactory *result = 0 ;
91991
91992   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91993   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91994   if (!arg2) {
91995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91996     return 0;
91997   }
91998   {
91999     try {
92000       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92001     } catch (std::out_of_range& e) {
92002       {
92003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92004       };
92005     } catch (std::exception& e) {
92006       {
92007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92008       };
92009     } catch (Dali::DaliException e) {
92010       {
92011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92012       };
92013     } catch (...) {
92014       {
92015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92016       };
92017     }
92018   }
92019
92020   jresult = (void *)result;
92021   return jresult;
92022 }
92023
92024
92025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92026   void * jresult ;
92027   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92028   Dali::Property::Map *arg2 = 0 ;
92029   Dali::Toolkit::Visual::Base result;
92030
92031   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92032   arg2 = (Dali::Property::Map *)jarg2;
92033   if (!arg2) {
92034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92035     return 0;
92036   }
92037   {
92038     try {
92039       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92040     } catch (std::out_of_range& e) {
92041       {
92042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92043       };
92044     } catch (std::exception& e) {
92045       {
92046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92047       };
92048     } catch (Dali::DaliException e) {
92049       {
92050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92051       };
92052     } catch (...) {
92053       {
92054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92055       };
92056     }
92057   }
92058
92059   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92060   return jresult;
92061 }
92062
92063
92064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92065   void * jresult ;
92066   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92067   Dali::Image *arg2 = 0 ;
92068   Dali::Toolkit::Visual::Base result;
92069
92070   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92071   arg2 = (Dali::Image *)jarg2;
92072   if (!arg2) {
92073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92074     return 0;
92075   }
92076   {
92077     try {
92078       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92079     } catch (std::out_of_range& e) {
92080       {
92081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92082       };
92083     } catch (std::exception& e) {
92084       {
92085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92086       };
92087     } catch (Dali::DaliException e) {
92088       {
92089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92090       };
92091     } catch (...) {
92092       {
92093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92094       };
92095     }
92096   }
92097
92098   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92099   return jresult;
92100 }
92101
92102
92103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92104   void * jresult ;
92105   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92106   std::string *arg2 = 0 ;
92107   Dali::ImageDimensions arg3 ;
92108   Dali::ImageDimensions *argp3 ;
92109   Dali::Toolkit::Visual::Base result;
92110
92111   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92112   if (!jarg2) {
92113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92114     return 0;
92115   }
92116   std::string arg2_str(jarg2);
92117   arg2 = &arg2_str;
92118   argp3 = (Dali::ImageDimensions *)jarg3;
92119   if (!argp3) {
92120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92121     return 0;
92122   }
92123   arg3 = *argp3;
92124   {
92125     try {
92126       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92127     } catch (std::out_of_range& e) {
92128       {
92129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92130       };
92131     } catch (std::exception& e) {
92132       {
92133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92134       };
92135     } catch (Dali::DaliException e) {
92136       {
92137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92138       };
92139     } catch (...) {
92140       {
92141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92142       };
92143     }
92144   }
92145
92146   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92147
92148   //argout typemap for const std::string&
92149
92150   return jresult;
92151 }
92152
92153
92154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92155   void * jresult ;
92156   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92157
92158   {
92159     try {
92160       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92161     } catch (std::out_of_range& e) {
92162       {
92163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92164       };
92165     } catch (std::exception& e) {
92166       {
92167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92168       };
92169     } catch (Dali::DaliException e) {
92170       {
92171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92172       };
92173     } catch (...) {
92174       {
92175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92176       };
92177     }
92178   }
92179
92180   jresult = (void *)result;
92181   return jresult;
92182 }
92183
92184
92185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92186   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92187
92188   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92189   {
92190     try {
92191       delete arg1;
92192     } catch (std::out_of_range& e) {
92193       {
92194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92195       };
92196     } catch (std::exception& e) {
92197       {
92198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92199       };
92200     } catch (Dali::DaliException e) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92203       };
92204     } catch (...) {
92205       {
92206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92207       };
92208     }
92209   }
92210
92211 }
92212
92213
92214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92215   void * jresult ;
92216   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92217   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92218
92219   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92220   if (!arg1) {
92221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92222     return 0;
92223   }
92224   {
92225     try {
92226       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92227     } catch (std::out_of_range& e) {
92228       {
92229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92230       };
92231     } catch (std::exception& e) {
92232       {
92233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92234       };
92235     } catch (Dali::DaliException e) {
92236       {
92237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92238       };
92239     } catch (...) {
92240       {
92241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92242       };
92243     }
92244   }
92245
92246   jresult = (void *)result;
92247   return jresult;
92248 }
92249
92250
92251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92252   void * jresult ;
92253   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92254   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92255   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92256
92257   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92258   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92259   if (!arg2) {
92260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92261     return 0;
92262   }
92263   {
92264     try {
92265       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (Dali::DaliException e) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92277       };
92278     } catch (...) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92281       };
92282     }
92283   }
92284
92285   jresult = (void *)result;
92286   return jresult;
92287 }
92288
92289
92290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92291   void * jresult ;
92292   Dali::Toolkit::AsyncImageLoader result;
92293
92294   {
92295     try {
92296       result = Dali::Toolkit::AsyncImageLoader::New();
92297     } catch (std::out_of_range& e) {
92298       {
92299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92300       };
92301     } catch (std::exception& e) {
92302       {
92303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92304       };
92305     } catch (Dali::DaliException e) {
92306       {
92307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92308       };
92309     } catch (...) {
92310       {
92311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92312       };
92313     }
92314   }
92315
92316   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92317   return jresult;
92318 }
92319
92320
92321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92322   void * jresult ;
92323   Dali::BaseHandle arg1 ;
92324   Dali::BaseHandle *argp1 ;
92325   Dali::Toolkit::AsyncImageLoader result;
92326
92327   argp1 = (Dali::BaseHandle *)jarg1;
92328   if (!argp1) {
92329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92330     return 0;
92331   }
92332   arg1 = *argp1;
92333   {
92334     try {
92335       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92336     } catch (std::out_of_range& e) {
92337       {
92338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92339       };
92340     } catch (std::exception& e) {
92341       {
92342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (Dali::DaliException e) {
92345       {
92346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92347       };
92348     } catch (...) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92351       };
92352     }
92353   }
92354
92355   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92356   return jresult;
92357 }
92358
92359
92360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92361   unsigned int jresult ;
92362   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92363   std::string *arg2 = 0 ;
92364   uint32_t result;
92365
92366   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92367   if (!jarg2) {
92368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92369     return 0;
92370   }
92371   std::string arg2_str(jarg2);
92372   arg2 = &arg2_str;
92373   {
92374     try {
92375       result = (arg1)->Load((std::string const &)*arg2);
92376     } catch (std::out_of_range& e) {
92377       {
92378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92379       };
92380     } catch (std::exception& e) {
92381       {
92382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92383       };
92384     } catch (Dali::DaliException e) {
92385       {
92386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92387       };
92388     } catch (...) {
92389       {
92390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92391       };
92392     }
92393   }
92394
92395   jresult = result;
92396
92397   //argout typemap for const std::string&
92398
92399   return jresult;
92400 }
92401
92402
92403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92404   unsigned int jresult ;
92405   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92406   std::string *arg2 = 0 ;
92407   Dali::ImageDimensions arg3 ;
92408   Dali::ImageDimensions *argp3 ;
92409   uint32_t result;
92410
92411   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92412   if (!jarg2) {
92413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92414     return 0;
92415   }
92416   std::string arg2_str(jarg2);
92417   arg2 = &arg2_str;
92418   argp3 = (Dali::ImageDimensions *)jarg3;
92419   if (!argp3) {
92420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92421     return 0;
92422   }
92423   arg3 = *argp3;
92424   {
92425     try {
92426       result = (arg1)->Load((std::string const &)*arg2,arg3);
92427     } catch (std::out_of_range& e) {
92428       {
92429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92430       };
92431     } catch (std::exception& e) {
92432       {
92433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92434       };
92435     } catch (Dali::DaliException e) {
92436       {
92437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92438       };
92439     } catch (...) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92442       };
92443     }
92444   }
92445
92446   jresult = result;
92447
92448   //argout typemap for const std::string&
92449
92450   return jresult;
92451 }
92452
92453
92454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92455   unsigned int jresult ;
92456   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92457   std::string *arg2 = 0 ;
92458   Dali::ImageDimensions arg3 ;
92459   Dali::FittingMode::Type arg4 ;
92460   Dali::SamplingMode::Type arg5 ;
92461   bool arg6 ;
92462   Dali::ImageDimensions *argp3 ;
92463   uint32_t result;
92464
92465   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92466   if (!jarg2) {
92467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92468     return 0;
92469   }
92470   std::string arg2_str(jarg2);
92471   arg2 = &arg2_str;
92472   argp3 = (Dali::ImageDimensions *)jarg3;
92473   if (!argp3) {
92474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92475     return 0;
92476   }
92477   arg3 = *argp3;
92478   arg4 = (Dali::FittingMode::Type)jarg4;
92479   arg5 = (Dali::SamplingMode::Type)jarg5;
92480   arg6 = jarg6 ? true : false;
92481   {
92482     try {
92483       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92484     } catch (std::out_of_range& e) {
92485       {
92486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92487       };
92488     } catch (std::exception& e) {
92489       {
92490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92491       };
92492     } catch (Dali::DaliException e) {
92493       {
92494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92495       };
92496     } catch (...) {
92497       {
92498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92499       };
92500     }
92501   }
92502
92503   jresult = result;
92504
92505   //argout typemap for const std::string&
92506
92507   return jresult;
92508 }
92509
92510
92511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92512   unsigned int jresult ;
92513   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92514   uint32_t arg2 ;
92515   bool result;
92516
92517   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92518   arg2 = (uint32_t)jarg2;
92519   {
92520     try {
92521       result = (bool)(arg1)->Cancel(arg2);
92522     } catch (std::out_of_range& e) {
92523       {
92524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92525       };
92526     } catch (std::exception& e) {
92527       {
92528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92529       };
92530     } catch (Dali::DaliException e) {
92531       {
92532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92533       };
92534     } catch (...) {
92535       {
92536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92537       };
92538     }
92539   }
92540
92541   jresult = result;
92542   return jresult;
92543 }
92544
92545
92546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92547   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92548
92549   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92550   {
92551     try {
92552       (arg1)->CancelAll();
92553     } catch (std::out_of_range& e) {
92554       {
92555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92556       };
92557     } catch (std::exception& e) {
92558       {
92559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92560       };
92561     } catch (Dali::DaliException e) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92564       };
92565     } catch (...) {
92566       {
92567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92568       };
92569     }
92570   }
92571
92572 }
92573
92574
92575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92576   void * jresult ;
92577   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92578   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92579
92580   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92581   {
92582     try {
92583       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92584     } catch (std::out_of_range& e) {
92585       {
92586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (std::exception& e) {
92589       {
92590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92591       };
92592     } catch (Dali::DaliException e) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92595       };
92596     } catch (...) {
92597       {
92598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92599       };
92600     }
92601   }
92602
92603   jresult = (void *)result;
92604   return jresult;
92605 }
92606
92607
92608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92609   void * jresult ;
92610   std::string *arg1 = 0 ;
92611   Dali::PixelData result;
92612
92613   if (!jarg1) {
92614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92615     return 0;
92616   }
92617   std::string arg1_str(jarg1);
92618   arg1 = &arg1_str;
92619   {
92620     try {
92621       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92622     } catch (std::out_of_range& e) {
92623       {
92624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92625       };
92626     } catch (std::exception& e) {
92627       {
92628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92629       };
92630     } catch (Dali::DaliException e) {
92631       {
92632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92633       };
92634     } catch (...) {
92635       {
92636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92637       };
92638     }
92639   }
92640
92641   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92642
92643   //argout typemap for const std::string&
92644
92645   return jresult;
92646 }
92647
92648
92649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92650   void * jresult ;
92651   std::string *arg1 = 0 ;
92652   Dali::ImageDimensions arg2 ;
92653   Dali::ImageDimensions *argp2 ;
92654   Dali::PixelData result;
92655
92656   if (!jarg1) {
92657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92658     return 0;
92659   }
92660   std::string arg1_str(jarg1);
92661   arg1 = &arg1_str;
92662   argp2 = (Dali::ImageDimensions *)jarg2;
92663   if (!argp2) {
92664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92665     return 0;
92666   }
92667   arg2 = *argp2;
92668   {
92669     try {
92670       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92671     } catch (std::out_of_range& e) {
92672       {
92673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92674       };
92675     } catch (std::exception& e) {
92676       {
92677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92678       };
92679     } catch (Dali::DaliException e) {
92680       {
92681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92682       };
92683     } catch (...) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92686       };
92687     }
92688   }
92689
92690   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92691
92692   //argout typemap for const std::string&
92693
92694   return jresult;
92695 }
92696
92697
92698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92699   void * jresult ;
92700   std::string *arg1 = 0 ;
92701   Dali::ImageDimensions arg2 ;
92702   Dali::FittingMode::Type arg3 ;
92703   Dali::SamplingMode::Type arg4 ;
92704   bool arg5 ;
92705   Dali::ImageDimensions *argp2 ;
92706   Dali::PixelData result;
92707
92708   if (!jarg1) {
92709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92710     return 0;
92711   }
92712   std::string arg1_str(jarg1);
92713   arg1 = &arg1_str;
92714   argp2 = (Dali::ImageDimensions *)jarg2;
92715   if (!argp2) {
92716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92717     return 0;
92718   }
92719   arg2 = *argp2;
92720   arg3 = (Dali::FittingMode::Type)jarg3;
92721   arg4 = (Dali::SamplingMode::Type)jarg4;
92722   arg5 = jarg5 ? true : false;
92723   {
92724     try {
92725       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92741       };
92742     }
92743   }
92744
92745   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92746
92747   //argout typemap for const std::string&
92748
92749   return jresult;
92750 }
92751
92752
92753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92754   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92755
92756   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92757   {
92758     try {
92759       delete arg1;
92760     } catch (std::out_of_range& e) {
92761       {
92762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92763       };
92764     } catch (std::exception& e) {
92765       {
92766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92767       };
92768     } catch (Dali::DaliException e) {
92769       {
92770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92771       };
92772     } catch (...) {
92773       {
92774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92775       };
92776     }
92777   }
92778
92779 }
92780
92781
92782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92783   void * jresult ;
92784   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92785   Dali::Actor arg2 ;
92786   Dali::Actor arg3 ;
92787   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92788   Dali::Actor *argp2 ;
92789   Dali::Actor *argp3 ;
92790   Dali::Actor result;
92791
92792   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92793   argp2 = (Dali::Actor *)jarg2;
92794   if (!argp2) {
92795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92796     return 0;
92797   }
92798   arg2 = *argp2;
92799   argp3 = (Dali::Actor *)jarg3;
92800   if (!argp3) {
92801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92802     return 0;
92803   }
92804   arg3 = *argp3;
92805   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92806   {
92807     try {
92808       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92809     } catch (std::out_of_range& e) {
92810       {
92811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92812       };
92813     } catch (std::exception& e) {
92814       {
92815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92816       };
92817     } catch (Dali::DaliException e) {
92818       {
92819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92820       };
92821     } catch (...) {
92822       {
92823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92824       };
92825     }
92826   }
92827
92828   jresult = new Dali::Actor((const Dali::Actor &)result);
92829   return jresult;
92830 }
92831
92832
92833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92834   void * jresult ;
92835   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92836
92837   {
92838     try {
92839       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92840     } catch (std::out_of_range& e) {
92841       {
92842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92843       };
92844     } catch (std::exception& e) {
92845       {
92846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92847       };
92848     } catch (Dali::DaliException e) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92851       };
92852     } catch (...) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92855       };
92856     }
92857   }
92858
92859   jresult = (void *)result;
92860   return jresult;
92861 }
92862
92863
92864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92865   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92866   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92867   if (director) {
92868     director->swig_connect_director(callback0);
92869   }
92870 }
92871
92872
92873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92874   KeyboardFocusManager arg1 ;
92875   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92876   KeyboardFocusManager *argp1 ;
92877
92878   argp1 = (KeyboardFocusManager *)jarg1;
92879   if (!argp1) {
92880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92881     return ;
92882   }
92883   arg1 = *argp1;
92884   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92885   if (!arg2) {
92886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92887     return ;
92888   }
92889   {
92890     try {
92891       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92892     } catch (std::out_of_range& e) {
92893       {
92894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92895       };
92896     } catch (std::exception& e) {
92897       {
92898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92899       };
92900     } catch (Dali::DaliException e) {
92901       {
92902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92903       };
92904     } catch (...) {
92905       {
92906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92907       };
92908     }
92909   }
92910
92911 }
92912
92913
92914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92915   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92916
92917   arg1 = (std::vector< unsigned int > *)jarg1;
92918   {
92919     try {
92920       (arg1)->clear();
92921     } catch (std::out_of_range& e) {
92922       {
92923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92924       };
92925     } catch (std::exception& e) {
92926       {
92927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92928       };
92929     } catch (Dali::DaliException e) {
92930       {
92931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92932       };
92933     } catch (...) {
92934       {
92935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92936       };
92937     }
92938   }
92939
92940 }
92941
92942
92943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92944   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92945   unsigned int *arg2 = 0 ;
92946   unsigned int temp2 ;
92947
92948   arg1 = (std::vector< unsigned int > *)jarg1;
92949   temp2 = (unsigned int)jarg2;
92950   arg2 = &temp2;
92951   {
92952     try {
92953       (arg1)->push_back((unsigned int const &)*arg2);
92954     } catch (std::out_of_range& e) {
92955       {
92956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92957       };
92958     } catch (std::exception& e) {
92959       {
92960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92961       };
92962     } catch (Dali::DaliException e) {
92963       {
92964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92965       };
92966     } catch (...) {
92967       {
92968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92969       };
92970     }
92971   }
92972
92973 }
92974
92975
92976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92977   unsigned long jresult ;
92978   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92979   std::vector< unsigned int >::size_type result;
92980
92981   arg1 = (std::vector< unsigned int > *)jarg1;
92982   {
92983     try {
92984       result = ((std::vector< unsigned int > const *)arg1)->size();
92985     } catch (std::out_of_range& e) {
92986       {
92987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92988       };
92989     } catch (std::exception& e) {
92990       {
92991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92992       };
92993     } catch (Dali::DaliException e) {
92994       {
92995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92996       };
92997     } catch (...) {
92998       {
92999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93000       };
93001     }
93002   }
93003
93004   jresult = (unsigned long)result;
93005   return jresult;
93006 }
93007
93008
93009 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93010   unsigned long jresult ;
93011   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93012   std::vector< unsigned int >::size_type result;
93013
93014   arg1 = (std::vector< unsigned int > *)jarg1;
93015   {
93016     try {
93017       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93018     } catch (std::out_of_range& e) {
93019       {
93020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93021       };
93022     } catch (std::exception& e) {
93023       {
93024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93025       };
93026     } catch (Dali::DaliException e) {
93027       {
93028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93029       };
93030     } catch (...) {
93031       {
93032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93033       };
93034     }
93035   }
93036
93037   jresult = (unsigned long)result;
93038   return jresult;
93039 }
93040
93041
93042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93043   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93044   std::vector< unsigned int >::size_type arg2 ;
93045
93046   arg1 = (std::vector< unsigned int > *)jarg1;
93047   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93048   {
93049     try {
93050       (arg1)->reserve(arg2);
93051     } catch (std::out_of_range& e) {
93052       {
93053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93054       };
93055     } catch (std::exception& e) {
93056       {
93057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93058       };
93059     } catch (Dali::DaliException e) {
93060       {
93061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93062       };
93063     } catch (...) {
93064       {
93065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93066       };
93067     }
93068   }
93069
93070 }
93071
93072
93073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93074   void * jresult ;
93075   std::vector< unsigned int > *result = 0 ;
93076
93077   {
93078     try {
93079       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93080     } catch (std::out_of_range& e) {
93081       {
93082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93083       };
93084     } catch (std::exception& e) {
93085       {
93086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93087       };
93088     } catch (Dali::DaliException e) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93091       };
93092     } catch (...) {
93093       {
93094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93095       };
93096     }
93097   }
93098
93099   jresult = (void *)result;
93100   return jresult;
93101 }
93102
93103
93104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93105   void * jresult ;
93106   std::vector< unsigned int > *arg1 = 0 ;
93107   std::vector< unsigned int > *result = 0 ;
93108
93109   arg1 = (std::vector< unsigned int > *)jarg1;
93110   if (!arg1) {
93111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93112     return 0;
93113   }
93114   {
93115     try {
93116       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93117     } catch (std::out_of_range& e) {
93118       {
93119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93120       };
93121     } catch (std::exception& e) {
93122       {
93123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93124       };
93125     } catch (Dali::DaliException e) {
93126       {
93127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93128       };
93129     } catch (...) {
93130       {
93131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93132       };
93133     }
93134   }
93135
93136   jresult = (void *)result;
93137   return jresult;
93138 }
93139
93140
93141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93142   void * jresult ;
93143   int arg1 ;
93144   std::vector< unsigned int > *result = 0 ;
93145
93146   arg1 = (int)jarg1;
93147   {
93148     try {
93149       try {
93150         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93151       }
93152       catch(std::out_of_range &_e) {
93153         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93154         return 0;
93155       }
93156
93157     } catch (std::out_of_range& e) {
93158       {
93159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93160       };
93161     } catch (std::exception& e) {
93162       {
93163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93164       };
93165     } catch (Dali::DaliException e) {
93166       {
93167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93168       };
93169     } catch (...) {
93170       {
93171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93172       };
93173     }
93174   }
93175
93176   jresult = (void *)result;
93177   return jresult;
93178 }
93179
93180
93181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93182   unsigned int jresult ;
93183   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93184   int arg2 ;
93185   unsigned int result;
93186
93187   arg1 = (std::vector< unsigned int > *)jarg1;
93188   arg2 = (int)jarg2;
93189   {
93190     try {
93191       try {
93192         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93193       }
93194       catch(std::out_of_range &_e) {
93195         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93196         return 0;
93197       }
93198
93199     } catch (std::out_of_range& e) {
93200       {
93201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93202       };
93203     } catch (std::exception& e) {
93204       {
93205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93206       };
93207     } catch (Dali::DaliException e) {
93208       {
93209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93210       };
93211     } catch (...) {
93212       {
93213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93214       };
93215     }
93216   }
93217
93218   jresult = result;
93219   return jresult;
93220 }
93221
93222
93223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93224   unsigned int jresult ;
93225   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93226   int arg2 ;
93227   unsigned int *result = 0 ;
93228
93229   arg1 = (std::vector< unsigned int > *)jarg1;
93230   arg2 = (int)jarg2;
93231   {
93232     try {
93233       try {
93234         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93235       }
93236       catch(std::out_of_range &_e) {
93237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93238         return 0;
93239       }
93240
93241     } catch (std::out_of_range& e) {
93242       {
93243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93244       };
93245     } catch (std::exception& e) {
93246       {
93247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93248       };
93249     } catch (Dali::DaliException e) {
93250       {
93251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93252       };
93253     } catch (...) {
93254       {
93255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93256       };
93257     }
93258   }
93259
93260   jresult = *result;
93261   return jresult;
93262 }
93263
93264
93265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93266   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93267   int arg2 ;
93268   unsigned int *arg3 = 0 ;
93269   unsigned int temp3 ;
93270
93271   arg1 = (std::vector< unsigned int > *)jarg1;
93272   arg2 = (int)jarg2;
93273   temp3 = (unsigned int)jarg3;
93274   arg3 = &temp3;
93275   {
93276     try {
93277       try {
93278         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93279       }
93280       catch(std::out_of_range &_e) {
93281         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93282         return ;
93283       }
93284
93285     } catch (std::out_of_range& e) {
93286       {
93287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93288       };
93289     } catch (std::exception& e) {
93290       {
93291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93292       };
93293     } catch (Dali::DaliException e) {
93294       {
93295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93296       };
93297     } catch (...) {
93298       {
93299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93300       };
93301     }
93302   }
93303
93304 }
93305
93306
93307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93308   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93309   std::vector< unsigned int > *arg2 = 0 ;
93310
93311   arg1 = (std::vector< unsigned int > *)jarg1;
93312   arg2 = (std::vector< unsigned int > *)jarg2;
93313   if (!arg2) {
93314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93315     return ;
93316   }
93317   {
93318     try {
93319       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93320     } catch (std::out_of_range& e) {
93321       {
93322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93323       };
93324     } catch (std::exception& e) {
93325       {
93326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93327       };
93328     } catch (Dali::DaliException e) {
93329       {
93330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93331       };
93332     } catch (...) {
93333       {
93334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93335       };
93336     }
93337   }
93338
93339 }
93340
93341
93342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93343   void * jresult ;
93344   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93345   int arg2 ;
93346   int arg3 ;
93347   std::vector< unsigned int > *result = 0 ;
93348
93349   arg1 = (std::vector< unsigned int > *)jarg1;
93350   arg2 = (int)jarg2;
93351   arg3 = (int)jarg3;
93352   {
93353     try {
93354       try {
93355         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93356       }
93357       catch(std::out_of_range &_e) {
93358         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93359         return 0;
93360       }
93361       catch(std::invalid_argument &_e) {
93362         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93363         return 0;
93364       }
93365
93366     } catch (std::out_of_range& e) {
93367       {
93368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93369       };
93370     } catch (std::exception& e) {
93371       {
93372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93373       };
93374     } catch (Dali::DaliException e) {
93375       {
93376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93377       };
93378     } catch (...) {
93379       {
93380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93381       };
93382     }
93383   }
93384
93385   jresult = (void *)result;
93386   return jresult;
93387 }
93388
93389
93390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93391   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93392   int arg2 ;
93393   unsigned int *arg3 = 0 ;
93394   unsigned int temp3 ;
93395
93396   arg1 = (std::vector< unsigned int > *)jarg1;
93397   arg2 = (int)jarg2;
93398   temp3 = (unsigned int)jarg3;
93399   arg3 = &temp3;
93400   {
93401     try {
93402       try {
93403         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93404       }
93405       catch(std::out_of_range &_e) {
93406         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93407         return ;
93408       }
93409
93410     } catch (std::out_of_range& e) {
93411       {
93412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93413       };
93414     } catch (std::exception& e) {
93415       {
93416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93417       };
93418     } catch (Dali::DaliException e) {
93419       {
93420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93421       };
93422     } catch (...) {
93423       {
93424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93425       };
93426     }
93427   }
93428
93429 }
93430
93431
93432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93433   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93434   int arg2 ;
93435   std::vector< unsigned int > *arg3 = 0 ;
93436
93437   arg1 = (std::vector< unsigned int > *)jarg1;
93438   arg2 = (int)jarg2;
93439   arg3 = (std::vector< unsigned int > *)jarg3;
93440   if (!arg3) {
93441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93442     return ;
93443   }
93444   {
93445     try {
93446       try {
93447         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93448       }
93449       catch(std::out_of_range &_e) {
93450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93451         return ;
93452       }
93453
93454     } catch (std::out_of_range& e) {
93455       {
93456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93457       };
93458     } catch (std::exception& e) {
93459       {
93460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93461       };
93462     } catch (Dali::DaliException e) {
93463       {
93464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93465       };
93466     } catch (...) {
93467       {
93468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93469       };
93470     }
93471   }
93472
93473 }
93474
93475
93476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93477   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93478   int arg2 ;
93479
93480   arg1 = (std::vector< unsigned int > *)jarg1;
93481   arg2 = (int)jarg2;
93482   {
93483     try {
93484       try {
93485         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93486       }
93487       catch(std::out_of_range &_e) {
93488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93489         return ;
93490       }
93491
93492     } catch (std::out_of_range& e) {
93493       {
93494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93495       };
93496     } catch (std::exception& e) {
93497       {
93498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93499       };
93500     } catch (Dali::DaliException e) {
93501       {
93502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93503       };
93504     } catch (...) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93507       };
93508     }
93509   }
93510
93511 }
93512
93513
93514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93515   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93516   int arg2 ;
93517   int arg3 ;
93518
93519   arg1 = (std::vector< unsigned int > *)jarg1;
93520   arg2 = (int)jarg2;
93521   arg3 = (int)jarg3;
93522   {
93523     try {
93524       try {
93525         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93526       }
93527       catch(std::out_of_range &_e) {
93528         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93529         return ;
93530       }
93531       catch(std::invalid_argument &_e) {
93532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93533         return ;
93534       }
93535
93536     } catch (std::out_of_range& e) {
93537       {
93538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93539       };
93540     } catch (std::exception& e) {
93541       {
93542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93543       };
93544     } catch (Dali::DaliException e) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93551       };
93552     }
93553   }
93554
93555 }
93556
93557
93558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93559   void * jresult ;
93560   unsigned int *arg1 = 0 ;
93561   int arg2 ;
93562   unsigned int temp1 ;
93563   std::vector< unsigned int > *result = 0 ;
93564
93565   temp1 = (unsigned int)jarg1;
93566   arg1 = &temp1;
93567   arg2 = (int)jarg2;
93568   {
93569     try {
93570       try {
93571         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93572       }
93573       catch(std::out_of_range &_e) {
93574         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93575         return 0;
93576       }
93577
93578     } catch (std::out_of_range& e) {
93579       {
93580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93581       };
93582     } catch (std::exception& e) {
93583       {
93584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93585       };
93586     } catch (Dali::DaliException e) {
93587       {
93588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93589       };
93590     } catch (...) {
93591       {
93592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93593       };
93594     }
93595   }
93596
93597   jresult = (void *)result;
93598   return jresult;
93599 }
93600
93601
93602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93603   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93604
93605   arg1 = (std::vector< unsigned int > *)jarg1;
93606   {
93607     try {
93608       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93609     } catch (std::out_of_range& e) {
93610       {
93611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93612       };
93613     } catch (std::exception& e) {
93614       {
93615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93616       };
93617     } catch (Dali::DaliException e) {
93618       {
93619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93620       };
93621     } catch (...) {
93622       {
93623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93624       };
93625     }
93626   }
93627
93628 }
93629
93630
93631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93632   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93633   int arg2 ;
93634   int arg3 ;
93635
93636   arg1 = (std::vector< unsigned int > *)jarg1;
93637   arg2 = (int)jarg2;
93638   arg3 = (int)jarg3;
93639   {
93640     try {
93641       try {
93642         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93643       }
93644       catch(std::out_of_range &_e) {
93645         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93646         return ;
93647       }
93648       catch(std::invalid_argument &_e) {
93649         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93650         return ;
93651       }
93652
93653     } catch (std::out_of_range& e) {
93654       {
93655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93656       };
93657     } catch (std::exception& e) {
93658       {
93659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93660       };
93661     } catch (Dali::DaliException e) {
93662       {
93663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93664       };
93665     } catch (...) {
93666       {
93667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93668       };
93669     }
93670   }
93671
93672 }
93673
93674
93675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93676   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93677   int arg2 ;
93678   std::vector< unsigned int > *arg3 = 0 ;
93679
93680   arg1 = (std::vector< unsigned int > *)jarg1;
93681   arg2 = (int)jarg2;
93682   arg3 = (std::vector< unsigned int > *)jarg3;
93683   if (!arg3) {
93684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93685     return ;
93686   }
93687   {
93688     try {
93689       try {
93690         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93691       }
93692       catch(std::out_of_range &_e) {
93693         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93694         return ;
93695       }
93696
93697     } catch (std::out_of_range& e) {
93698       {
93699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93700       };
93701     } catch (std::exception& e) {
93702       {
93703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93704       };
93705     } catch (Dali::DaliException e) {
93706       {
93707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93708       };
93709     } catch (...) {
93710       {
93711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93712       };
93713     }
93714   }
93715
93716 }
93717
93718
93719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93720   unsigned int jresult ;
93721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93722   unsigned int *arg2 = 0 ;
93723   unsigned int temp2 ;
93724   bool result;
93725
93726   arg1 = (std::vector< unsigned int > *)jarg1;
93727   temp2 = (unsigned int)jarg2;
93728   arg2 = &temp2;
93729   {
93730     try {
93731       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93732     } catch (std::out_of_range& e) {
93733       {
93734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93735       };
93736     } catch (std::exception& e) {
93737       {
93738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93739       };
93740     } catch (Dali::DaliException e) {
93741       {
93742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93743       };
93744     } catch (...) {
93745       {
93746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93747       };
93748     }
93749   }
93750
93751   jresult = result;
93752   return jresult;
93753 }
93754
93755
93756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93757   int jresult ;
93758   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93759   unsigned int *arg2 = 0 ;
93760   unsigned int temp2 ;
93761   int result;
93762
93763   arg1 = (std::vector< unsigned int > *)jarg1;
93764   temp2 = (unsigned int)jarg2;
93765   arg2 = &temp2;
93766   {
93767     try {
93768       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93769     } catch (std::out_of_range& e) {
93770       {
93771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93772       };
93773     } catch (std::exception& e) {
93774       {
93775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93776       };
93777     } catch (Dali::DaliException e) {
93778       {
93779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93780       };
93781     } catch (...) {
93782       {
93783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93784       };
93785     }
93786   }
93787
93788   jresult = result;
93789   return jresult;
93790 }
93791
93792
93793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93794   int jresult ;
93795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93796   unsigned int *arg2 = 0 ;
93797   unsigned int temp2 ;
93798   int result;
93799
93800   arg1 = (std::vector< unsigned int > *)jarg1;
93801   temp2 = (unsigned int)jarg2;
93802   arg2 = &temp2;
93803   {
93804     try {
93805       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93806     } catch (std::out_of_range& e) {
93807       {
93808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93809       };
93810     } catch (std::exception& e) {
93811       {
93812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93813       };
93814     } catch (Dali::DaliException e) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93817       };
93818     } catch (...) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93821       };
93822     }
93823   }
93824
93825   jresult = result;
93826   return jresult;
93827 }
93828
93829
93830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93831   unsigned int jresult ;
93832   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93833   unsigned int *arg2 = 0 ;
93834   unsigned int temp2 ;
93835   bool result;
93836
93837   arg1 = (std::vector< unsigned int > *)jarg1;
93838   temp2 = (unsigned int)jarg2;
93839   arg2 = &temp2;
93840   {
93841     try {
93842       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93843     } catch (std::out_of_range& e) {
93844       {
93845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93846       };
93847     } catch (std::exception& e) {
93848       {
93849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93850       };
93851     } catch (Dali::DaliException e) {
93852       {
93853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93854       };
93855     } catch (...) {
93856       {
93857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93858       };
93859     }
93860   }
93861
93862   jresult = result;
93863   return jresult;
93864 }
93865
93866
93867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93868   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93869
93870   arg1 = (std::vector< unsigned int > *)jarg1;
93871   {
93872     try {
93873       delete arg1;
93874     } catch (std::out_of_range& e) {
93875       {
93876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93877       };
93878     } catch (std::exception& e) {
93879       {
93880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93881       };
93882     } catch (Dali::DaliException e) {
93883       {
93884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93885       };
93886     } catch (...) {
93887       {
93888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93889       };
93890     }
93891   }
93892
93893 }
93894
93895
93896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93897   void * jresult ;
93898   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93899
93900   {
93901     try {
93902       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93903     } catch (std::out_of_range& e) {
93904       {
93905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93906       };
93907     } catch (std::exception& e) {
93908       {
93909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93910       };
93911     } catch (Dali::DaliException e) {
93912       {
93913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93914       };
93915     } catch (...) {
93916       {
93917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93918       };
93919     }
93920   }
93921
93922   jresult = (void *)result;
93923   return jresult;
93924 }
93925
93926
93927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93928   void * jresult ;
93929   unsigned int arg1 ;
93930   Dali::Actor arg2 ;
93931   Dali::Actor *argp2 ;
93932   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93933
93934   arg1 = (unsigned int)jarg1;
93935   argp2 = (Dali::Actor *)jarg2;
93936   if (!argp2) {
93937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93938     return 0;
93939   }
93940   arg2 = *argp2;
93941   {
93942     try {
93943       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93944     } catch (std::out_of_range& e) {
93945       {
93946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93947       };
93948     } catch (std::exception& e) {
93949       {
93950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93951       };
93952     } catch (Dali::DaliException e) {
93953       {
93954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93955       };
93956     } catch (...) {
93957       {
93958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93959       };
93960     }
93961   }
93962
93963   jresult = (void *)result;
93964   return jresult;
93965 }
93966
93967
93968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93969   void * jresult ;
93970   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93971   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93972
93973   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93974   if (!arg1) {
93975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93976     return 0;
93977   }
93978   {
93979     try {
93980       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93981     } catch (std::out_of_range& e) {
93982       {
93983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93984       };
93985     } catch (std::exception& e) {
93986       {
93987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93988       };
93989     } catch (Dali::DaliException e) {
93990       {
93991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93992       };
93993     } catch (...) {
93994       {
93995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93996       };
93997     }
93998   }
93999
94000   jresult = (void *)result;
94001   return jresult;
94002 }
94003
94004
94005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94006   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94007   unsigned int arg2 ;
94008
94009   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94010   arg2 = (unsigned int)jarg2;
94011   if (arg1) (arg1)->first = arg2;
94012 }
94013
94014
94015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94016   unsigned int jresult ;
94017   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94018   unsigned int result;
94019
94020   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94021   result = (unsigned int) ((arg1)->first);
94022   jresult = result;
94023   return jresult;
94024 }
94025
94026
94027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94028   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94029   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94030
94031   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94032   arg2 = (Dali::Actor *)jarg2;
94033   if (arg1) (arg1)->second = *arg2;
94034 }
94035
94036
94037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94038   void * jresult ;
94039   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94040   Dali::Actor *result = 0 ;
94041
94042   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94043   result = (Dali::Actor *)& ((arg1)->second);
94044   jresult = (void *)result;
94045   return jresult;
94046 }
94047
94048
94049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94050   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94051
94052   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94053   {
94054     try {
94055       delete arg1;
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 void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94079   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94080
94081   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94082   {
94083     try {
94084       (arg1)->clear();
94085     } catch (std::out_of_range& e) {
94086       {
94087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94088       };
94089     } catch (std::exception& e) {
94090       {
94091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94092       };
94093     } catch (Dali::DaliException e) {
94094       {
94095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94096       };
94097     } catch (...) {
94098       {
94099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94100       };
94101     }
94102   }
94103
94104 }
94105
94106
94107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94108   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94109   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94110
94111   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94112   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94113   if (!arg2) {
94114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94115     return ;
94116   }
94117   {
94118     try {
94119       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94120     } catch (std::out_of_range& e) {
94121       {
94122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94123       };
94124     } catch (std::exception& e) {
94125       {
94126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94127       };
94128     } catch (Dali::DaliException e) {
94129       {
94130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94131       };
94132     } catch (...) {
94133       {
94134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94135       };
94136     }
94137   }
94138
94139 }
94140
94141
94142 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94143   unsigned long jresult ;
94144   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94145   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94146
94147   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94148   {
94149     try {
94150       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94151     } catch (std::out_of_range& e) {
94152       {
94153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94154       };
94155     } catch (std::exception& e) {
94156       {
94157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94158       };
94159     } catch (Dali::DaliException e) {
94160       {
94161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94162       };
94163     } catch (...) {
94164       {
94165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94166       };
94167     }
94168   }
94169
94170   jresult = (unsigned long)result;
94171   return jresult;
94172 }
94173
94174
94175 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94176   unsigned long jresult ;
94177   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94178   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94179
94180   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94181   {
94182     try {
94183       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94184     } catch (std::out_of_range& e) {
94185       {
94186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94187       };
94188     } catch (std::exception& e) {
94189       {
94190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94191       };
94192     } catch (Dali::DaliException e) {
94193       {
94194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94195       };
94196     } catch (...) {
94197       {
94198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94199       };
94200     }
94201   }
94202
94203   jresult = (unsigned long)result;
94204   return jresult;
94205 }
94206
94207
94208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94209   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94210   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94211
94212   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94213   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94214   {
94215     try {
94216       (arg1)->reserve(arg2);
94217     } catch (std::out_of_range& e) {
94218       {
94219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94220       };
94221     } catch (std::exception& e) {
94222       {
94223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94224       };
94225     } catch (Dali::DaliException e) {
94226       {
94227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94228       };
94229     } catch (...) {
94230       {
94231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94232       };
94233     }
94234   }
94235
94236 }
94237
94238
94239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94240   void * jresult ;
94241   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94242
94243   {
94244     try {
94245       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94246     } catch (std::out_of_range& e) {
94247       {
94248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94249       };
94250     } catch (std::exception& e) {
94251       {
94252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94253       };
94254     } catch (Dali::DaliException e) {
94255       {
94256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94257       };
94258     } catch (...) {
94259       {
94260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94261       };
94262     }
94263   }
94264
94265   jresult = (void *)result;
94266   return jresult;
94267 }
94268
94269
94270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94271   void * jresult ;
94272   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94273   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94274
94275   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94276   if (!arg1) {
94277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94278     return 0;
94279   }
94280   {
94281     try {
94282       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);
94283     } catch (std::out_of_range& e) {
94284       {
94285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94286       };
94287     } catch (std::exception& e) {
94288       {
94289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94290       };
94291     } catch (Dali::DaliException e) {
94292       {
94293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94294       };
94295     } catch (...) {
94296       {
94297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94298       };
94299     }
94300   }
94301
94302   jresult = (void *)result;
94303   return jresult;
94304 }
94305
94306
94307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94308   void * jresult ;
94309   int arg1 ;
94310   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94311
94312   arg1 = (int)jarg1;
94313   {
94314     try {
94315       try {
94316         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);
94317       }
94318       catch(std::out_of_range &_e) {
94319         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94320         return 0;
94321       }
94322
94323     } catch (std::out_of_range& e) {
94324       {
94325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94326       };
94327     } catch (std::exception& e) {
94328       {
94329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94330       };
94331     } catch (Dali::DaliException e) {
94332       {
94333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94334       };
94335     } catch (...) {
94336       {
94337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94338       };
94339     }
94340   }
94341
94342   jresult = (void *)result;
94343   return jresult;
94344 }
94345
94346
94347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94348   void * jresult ;
94349   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94350   int arg2 ;
94351   std::pair< unsigned int,Dali::Actor > result;
94352
94353   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94354   arg2 = (int)jarg2;
94355   {
94356     try {
94357       try {
94358         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94359       }
94360       catch(std::out_of_range &_e) {
94361         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94362         return 0;
94363       }
94364
94365     } catch (std::out_of_range& e) {
94366       {
94367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94368       };
94369     } catch (std::exception& e) {
94370       {
94371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94372       };
94373     } catch (Dali::DaliException e) {
94374       {
94375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94376       };
94377     } catch (...) {
94378       {
94379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94380       };
94381     }
94382   }
94383
94384   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94385   return jresult;
94386 }
94387
94388
94389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94390   void * jresult ;
94391   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94392   int arg2 ;
94393   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94394
94395   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94396   arg2 = (int)jarg2;
94397   {
94398     try {
94399       try {
94400         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94401       }
94402       catch(std::out_of_range &_e) {
94403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94404         return 0;
94405       }
94406
94407     } catch (std::out_of_range& e) {
94408       {
94409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94410       };
94411     } catch (std::exception& e) {
94412       {
94413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94414       };
94415     } catch (Dali::DaliException e) {
94416       {
94417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94418       };
94419     } catch (...) {
94420       {
94421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94422       };
94423     }
94424   }
94425
94426   jresult = (void *)result;
94427   return jresult;
94428 }
94429
94430
94431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94432   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94433   int arg2 ;
94434   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94435
94436   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94437   arg2 = (int)jarg2;
94438   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94439   if (!arg3) {
94440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94441     return ;
94442   }
94443   {
94444     try {
94445       try {
94446         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);
94447       }
94448       catch(std::out_of_range &_e) {
94449         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94450         return ;
94451       }
94452
94453     } catch (std::out_of_range& e) {
94454       {
94455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94456       };
94457     } catch (std::exception& e) {
94458       {
94459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94460       };
94461     } catch (Dali::DaliException e) {
94462       {
94463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94464       };
94465     } catch (...) {
94466       {
94467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94468       };
94469     }
94470   }
94471
94472 }
94473
94474
94475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94476   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94477   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94478
94479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94480   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94481   if (!arg2) {
94482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94483     return ;
94484   }
94485   {
94486     try {
94487       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);
94488     } catch (std::out_of_range& e) {
94489       {
94490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94491       };
94492     } catch (std::exception& e) {
94493       {
94494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94495       };
94496     } catch (Dali::DaliException e) {
94497       {
94498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94499       };
94500     } catch (...) {
94501       {
94502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94503       };
94504     }
94505   }
94506
94507 }
94508
94509
94510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94511   void * jresult ;
94512   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94513   int arg2 ;
94514   int arg3 ;
94515   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94516
94517   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94518   arg2 = (int)jarg2;
94519   arg3 = (int)jarg3;
94520   {
94521     try {
94522       try {
94523         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);
94524       }
94525       catch(std::out_of_range &_e) {
94526         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94527         return 0;
94528       }
94529       catch(std::invalid_argument &_e) {
94530         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94531         return 0;
94532       }
94533
94534     } catch (std::out_of_range& e) {
94535       {
94536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94537       };
94538     } catch (std::exception& e) {
94539       {
94540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94541       };
94542     } catch (Dali::DaliException e) {
94543       {
94544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94545       };
94546     } catch (...) {
94547       {
94548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94549       };
94550     }
94551   }
94552
94553   jresult = (void *)result;
94554   return jresult;
94555 }
94556
94557
94558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94559   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94560   int arg2 ;
94561   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94562
94563   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94564   arg2 = (int)jarg2;
94565   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94566   if (!arg3) {
94567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94568     return ;
94569   }
94570   {
94571     try {
94572       try {
94573         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);
94574       }
94575       catch(std::out_of_range &_e) {
94576         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94577         return ;
94578       }
94579
94580     } catch (std::out_of_range& e) {
94581       {
94582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94583       };
94584     } catch (std::exception& e) {
94585       {
94586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94587       };
94588     } catch (Dali::DaliException e) {
94589       {
94590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94591       };
94592     } catch (...) {
94593       {
94594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94595       };
94596     }
94597   }
94598
94599 }
94600
94601
94602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94603   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94604   int arg2 ;
94605   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94606
94607   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94608   arg2 = (int)jarg2;
94609   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94610   if (!arg3) {
94611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94612     return ;
94613   }
94614   {
94615     try {
94616       try {
94617         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);
94618       }
94619       catch(std::out_of_range &_e) {
94620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94621         return ;
94622       }
94623
94624     } catch (std::out_of_range& e) {
94625       {
94626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94627       };
94628     } catch (std::exception& e) {
94629       {
94630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94631       };
94632     } catch (Dali::DaliException e) {
94633       {
94634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94635       };
94636     } catch (...) {
94637       {
94638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94639       };
94640     }
94641   }
94642
94643 }
94644
94645
94646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94647   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94648   int arg2 ;
94649
94650   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94651   arg2 = (int)jarg2;
94652   {
94653     try {
94654       try {
94655         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94656       }
94657       catch(std::out_of_range &_e) {
94658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94659         return ;
94660       }
94661
94662     } catch (std::out_of_range& e) {
94663       {
94664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94665       };
94666     } catch (std::exception& e) {
94667       {
94668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94669       };
94670     } catch (Dali::DaliException e) {
94671       {
94672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94673       };
94674     } catch (...) {
94675       {
94676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94677       };
94678     }
94679   }
94680
94681 }
94682
94683
94684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94685   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94686   int arg2 ;
94687   int arg3 ;
94688
94689   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94690   arg2 = (int)jarg2;
94691   arg3 = (int)jarg3;
94692   {
94693     try {
94694       try {
94695         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94696       }
94697       catch(std::out_of_range &_e) {
94698         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94699         return ;
94700       }
94701       catch(std::invalid_argument &_e) {
94702         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94703         return ;
94704       }
94705
94706     } catch (std::out_of_range& e) {
94707       {
94708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94709       };
94710     } catch (std::exception& e) {
94711       {
94712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94713       };
94714     } catch (Dali::DaliException e) {
94715       {
94716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94717       };
94718     } catch (...) {
94719       {
94720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94721       };
94722     }
94723   }
94724
94725 }
94726
94727
94728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94729   void * jresult ;
94730   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94731   int arg2 ;
94732   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94733
94734   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94735   if (!arg1) {
94736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94737     return 0;
94738   }
94739   arg2 = (int)jarg2;
94740   {
94741     try {
94742       try {
94743         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);
94744       }
94745       catch(std::out_of_range &_e) {
94746         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94747         return 0;
94748       }
94749
94750     } catch (std::out_of_range& e) {
94751       {
94752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94753       };
94754     } catch (std::exception& e) {
94755       {
94756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94757       };
94758     } catch (Dali::DaliException e) {
94759       {
94760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94761       };
94762     } catch (...) {
94763       {
94764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94765       };
94766     }
94767   }
94768
94769   jresult = (void *)result;
94770   return jresult;
94771 }
94772
94773
94774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94775   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94776
94777   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94778   {
94779     try {
94780       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94781     } catch (std::out_of_range& e) {
94782       {
94783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94784       };
94785     } catch (std::exception& e) {
94786       {
94787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94788       };
94789     } catch (Dali::DaliException e) {
94790       {
94791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94792       };
94793     } catch (...) {
94794       {
94795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94796       };
94797     }
94798   }
94799
94800 }
94801
94802
94803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94804   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94805   int arg2 ;
94806   int arg3 ;
94807
94808   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94809   arg2 = (int)jarg2;
94810   arg3 = (int)jarg3;
94811   {
94812     try {
94813       try {
94814         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94815       }
94816       catch(std::out_of_range &_e) {
94817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94818         return ;
94819       }
94820       catch(std::invalid_argument &_e) {
94821         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94822         return ;
94823       }
94824
94825     } catch (std::out_of_range& e) {
94826       {
94827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94828       };
94829     } catch (std::exception& e) {
94830       {
94831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94832       };
94833     } catch (Dali::DaliException e) {
94834       {
94835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94836       };
94837     } catch (...) {
94838       {
94839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94840       };
94841     }
94842   }
94843
94844 }
94845
94846
94847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94848   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94849   int arg2 ;
94850   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94851
94852   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94853   arg2 = (int)jarg2;
94854   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94855   if (!arg3) {
94856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94857     return ;
94858   }
94859   {
94860     try {
94861       try {
94862         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);
94863       }
94864       catch(std::out_of_range &_e) {
94865         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94866         return ;
94867       }
94868
94869     } catch (std::out_of_range& e) {
94870       {
94871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94872       };
94873     } catch (std::exception& e) {
94874       {
94875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94876       };
94877     } catch (Dali::DaliException e) {
94878       {
94879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94880       };
94881     } catch (...) {
94882       {
94883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94884       };
94885     }
94886   }
94887
94888 }
94889
94890
94891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94892   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94893
94894   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94895   {
94896     try {
94897       delete arg1;
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 void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94921   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94922
94923   arg1 = (std::vector< Dali::Actor > *)jarg1;
94924   {
94925     try {
94926       (arg1)->clear();
94927     } catch (std::out_of_range& e) {
94928       {
94929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94930       };
94931     } catch (std::exception& e) {
94932       {
94933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94934       };
94935     } catch (Dali::DaliException e) {
94936       {
94937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94938       };
94939     } catch (...) {
94940       {
94941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94942       };
94943     }
94944   }
94945
94946 }
94947
94948
94949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94950   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94951   Dali::Actor *arg2 = 0 ;
94952
94953   arg1 = (std::vector< Dali::Actor > *)jarg1;
94954   arg2 = (Dali::Actor *)jarg2;
94955   if (!arg2) {
94956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94957     return ;
94958   }
94959   {
94960     try {
94961       (arg1)->push_back((Dali::Actor const &)*arg2);
94962     } catch (std::out_of_range& e) {
94963       {
94964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94965       };
94966     } catch (std::exception& e) {
94967       {
94968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94969       };
94970     } catch (Dali::DaliException e) {
94971       {
94972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94973       };
94974     } catch (...) {
94975       {
94976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94977       };
94978     }
94979   }
94980
94981 }
94982
94983
94984 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94985   unsigned long jresult ;
94986   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94987   std::vector< Dali::Actor >::size_type result;
94988
94989   arg1 = (std::vector< Dali::Actor > *)jarg1;
94990   {
94991     try {
94992       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94993     } catch (std::out_of_range& e) {
94994       {
94995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94996       };
94997     } catch (std::exception& e) {
94998       {
94999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95000       };
95001     } catch (Dali::DaliException e) {
95002       {
95003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95004       };
95005     } catch (...) {
95006       {
95007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95008       };
95009     }
95010   }
95011
95012   jresult = (unsigned long)result;
95013   return jresult;
95014 }
95015
95016
95017 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95018   unsigned long jresult ;
95019   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95020   std::vector< Dali::Actor >::size_type result;
95021
95022   arg1 = (std::vector< Dali::Actor > *)jarg1;
95023   {
95024     try {
95025       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95026     } catch (std::out_of_range& e) {
95027       {
95028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95029       };
95030     } catch (std::exception& e) {
95031       {
95032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95033       };
95034     } catch (Dali::DaliException e) {
95035       {
95036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95037       };
95038     } catch (...) {
95039       {
95040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95041       };
95042     }
95043   }
95044
95045   jresult = (unsigned long)result;
95046   return jresult;
95047 }
95048
95049
95050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95051   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95052   std::vector< Dali::Actor >::size_type arg2 ;
95053
95054   arg1 = (std::vector< Dali::Actor > *)jarg1;
95055   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95056   {
95057     try {
95058       (arg1)->reserve(arg2);
95059     } catch (std::out_of_range& e) {
95060       {
95061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95062       };
95063     } catch (std::exception& e) {
95064       {
95065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95066       };
95067     } catch (Dali::DaliException e) {
95068       {
95069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95070       };
95071     } catch (...) {
95072       {
95073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95074       };
95075     }
95076   }
95077
95078 }
95079
95080
95081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95082   void * jresult ;
95083   std::vector< Dali::Actor > *result = 0 ;
95084
95085   {
95086     try {
95087       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95088     } catch (std::out_of_range& e) {
95089       {
95090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95091       };
95092     } catch (std::exception& e) {
95093       {
95094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95095       };
95096     } catch (Dali::DaliException e) {
95097       {
95098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95099       };
95100     } catch (...) {
95101       {
95102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95103       };
95104     }
95105   }
95106
95107   jresult = (void *)result;
95108   return jresult;
95109 }
95110
95111
95112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95113   void * jresult ;
95114   std::vector< Dali::Actor > *arg1 = 0 ;
95115   std::vector< Dali::Actor > *result = 0 ;
95116
95117   arg1 = (std::vector< Dali::Actor > *)jarg1;
95118   if (!arg1) {
95119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95120     return 0;
95121   }
95122   {
95123     try {
95124       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95125     } catch (std::out_of_range& e) {
95126       {
95127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95128       };
95129     } catch (std::exception& e) {
95130       {
95131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95132       };
95133     } catch (Dali::DaliException e) {
95134       {
95135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95136       };
95137     } catch (...) {
95138       {
95139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95140       };
95141     }
95142   }
95143
95144   jresult = (void *)result;
95145   return jresult;
95146 }
95147
95148
95149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95150   void * jresult ;
95151   int arg1 ;
95152   std::vector< Dali::Actor > *result = 0 ;
95153
95154   arg1 = (int)jarg1;
95155   {
95156     try {
95157       try {
95158         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95159       }
95160       catch(std::out_of_range &_e) {
95161         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95162         return 0;
95163       }
95164
95165     } catch (std::out_of_range& e) {
95166       {
95167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95168       };
95169     } catch (std::exception& e) {
95170       {
95171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95172       };
95173     } catch (Dali::DaliException e) {
95174       {
95175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95176       };
95177     } catch (...) {
95178       {
95179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95180       };
95181     }
95182   }
95183
95184   jresult = (void *)result;
95185   return jresult;
95186 }
95187
95188
95189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95190   void * jresult ;
95191   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95192   int arg2 ;
95193   Dali::Actor result;
95194
95195   arg1 = (std::vector< Dali::Actor > *)jarg1;
95196   arg2 = (int)jarg2;
95197   {
95198     try {
95199       try {
95200         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95201       }
95202       catch(std::out_of_range &_e) {
95203         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95204         return 0;
95205       }
95206
95207     } catch (std::out_of_range& e) {
95208       {
95209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95210       };
95211     } catch (std::exception& e) {
95212       {
95213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95214       };
95215     } catch (Dali::DaliException e) {
95216       {
95217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95218       };
95219     } catch (...) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95222       };
95223     }
95224   }
95225
95226   jresult = new Dali::Actor((const Dali::Actor &)result);
95227   return jresult;
95228 }
95229
95230
95231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95232   void * jresult ;
95233   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95234   int arg2 ;
95235   Dali::Actor *result = 0 ;
95236
95237   arg1 = (std::vector< Dali::Actor > *)jarg1;
95238   arg2 = (int)jarg2;
95239   {
95240     try {
95241       try {
95242         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95243       }
95244       catch(std::out_of_range &_e) {
95245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95246         return 0;
95247       }
95248
95249     } catch (std::out_of_range& e) {
95250       {
95251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95252       };
95253     } catch (std::exception& e) {
95254       {
95255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95256       };
95257     } catch (Dali::DaliException e) {
95258       {
95259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95260       };
95261     } catch (...) {
95262       {
95263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95264       };
95265     }
95266   }
95267
95268   jresult = (void *)result;
95269   return jresult;
95270 }
95271
95272
95273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95274   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95275   int arg2 ;
95276   Dali::Actor *arg3 = 0 ;
95277
95278   arg1 = (std::vector< Dali::Actor > *)jarg1;
95279   arg2 = (int)jarg2;
95280   arg3 = (Dali::Actor *)jarg3;
95281   if (!arg3) {
95282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95283     return ;
95284   }
95285   {
95286     try {
95287       try {
95288         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95289       }
95290       catch(std::out_of_range &_e) {
95291         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95292         return ;
95293       }
95294
95295     } catch (std::out_of_range& e) {
95296       {
95297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95298       };
95299     } catch (std::exception& e) {
95300       {
95301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95302       };
95303     } catch (Dali::DaliException e) {
95304       {
95305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95306       };
95307     } catch (...) {
95308       {
95309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95310       };
95311     }
95312   }
95313
95314 }
95315
95316
95317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95318   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95319   std::vector< Dali::Actor > *arg2 = 0 ;
95320
95321   arg1 = (std::vector< Dali::Actor > *)jarg1;
95322   arg2 = (std::vector< Dali::Actor > *)jarg2;
95323   if (!arg2) {
95324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95325     return ;
95326   }
95327   {
95328     try {
95329       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95330     } catch (std::out_of_range& e) {
95331       {
95332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95333       };
95334     } catch (std::exception& e) {
95335       {
95336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95337       };
95338     } catch (Dali::DaliException e) {
95339       {
95340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95341       };
95342     } catch (...) {
95343       {
95344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95345       };
95346     }
95347   }
95348
95349 }
95350
95351
95352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95353   void * jresult ;
95354   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95355   int arg2 ;
95356   int arg3 ;
95357   std::vector< Dali::Actor > *result = 0 ;
95358
95359   arg1 = (std::vector< Dali::Actor > *)jarg1;
95360   arg2 = (int)jarg2;
95361   arg3 = (int)jarg3;
95362   {
95363     try {
95364       try {
95365         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95366       }
95367       catch(std::out_of_range &_e) {
95368         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95369         return 0;
95370       }
95371       catch(std::invalid_argument &_e) {
95372         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95373         return 0;
95374       }
95375
95376     } catch (std::out_of_range& e) {
95377       {
95378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95379       };
95380     } catch (std::exception& e) {
95381       {
95382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95383       };
95384     } catch (Dali::DaliException e) {
95385       {
95386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95387       };
95388     } catch (...) {
95389       {
95390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95391       };
95392     }
95393   }
95394
95395   jresult = (void *)result;
95396   return jresult;
95397 }
95398
95399
95400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95401   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95402   int arg2 ;
95403   Dali::Actor *arg3 = 0 ;
95404
95405   arg1 = (std::vector< Dali::Actor > *)jarg1;
95406   arg2 = (int)jarg2;
95407   arg3 = (Dali::Actor *)jarg3;
95408   if (!arg3) {
95409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95410     return ;
95411   }
95412   {
95413     try {
95414       try {
95415         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95416       }
95417       catch(std::out_of_range &_e) {
95418         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95419         return ;
95420       }
95421
95422     } catch (std::out_of_range& e) {
95423       {
95424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95425       };
95426     } catch (std::exception& e) {
95427       {
95428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95429       };
95430     } catch (Dali::DaliException e) {
95431       {
95432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95433       };
95434     } catch (...) {
95435       {
95436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95437       };
95438     }
95439   }
95440
95441 }
95442
95443
95444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95445   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95446   int arg2 ;
95447   std::vector< Dali::Actor > *arg3 = 0 ;
95448
95449   arg1 = (std::vector< Dali::Actor > *)jarg1;
95450   arg2 = (int)jarg2;
95451   arg3 = (std::vector< Dali::Actor > *)jarg3;
95452   if (!arg3) {
95453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95454     return ;
95455   }
95456   {
95457     try {
95458       try {
95459         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95460       }
95461       catch(std::out_of_range &_e) {
95462         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95463         return ;
95464       }
95465
95466     } catch (std::out_of_range& e) {
95467       {
95468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95469       };
95470     } catch (std::exception& e) {
95471       {
95472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95473       };
95474     } catch (Dali::DaliException e) {
95475       {
95476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95477       };
95478     } catch (...) {
95479       {
95480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95481       };
95482     }
95483   }
95484
95485 }
95486
95487
95488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95489   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95490   int arg2 ;
95491
95492   arg1 = (std::vector< Dali::Actor > *)jarg1;
95493   arg2 = (int)jarg2;
95494   {
95495     try {
95496       try {
95497         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95498       }
95499       catch(std::out_of_range &_e) {
95500         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95501         return ;
95502       }
95503
95504     } catch (std::out_of_range& e) {
95505       {
95506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95507       };
95508     } catch (std::exception& e) {
95509       {
95510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95511       };
95512     } catch (Dali::DaliException e) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95515       };
95516     } catch (...) {
95517       {
95518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95519       };
95520     }
95521   }
95522
95523 }
95524
95525
95526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95527   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95528   int arg2 ;
95529   int arg3 ;
95530
95531   arg1 = (std::vector< Dali::Actor > *)jarg1;
95532   arg2 = (int)jarg2;
95533   arg3 = (int)jarg3;
95534   {
95535     try {
95536       try {
95537         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95538       }
95539       catch(std::out_of_range &_e) {
95540         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95541         return ;
95542       }
95543       catch(std::invalid_argument &_e) {
95544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95545         return ;
95546       }
95547
95548     } catch (std::out_of_range& e) {
95549       {
95550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95551       };
95552     } catch (std::exception& e) {
95553       {
95554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95555       };
95556     } catch (Dali::DaliException e) {
95557       {
95558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95559       };
95560     } catch (...) {
95561       {
95562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95563       };
95564     }
95565   }
95566
95567 }
95568
95569
95570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95571   void * jresult ;
95572   Dali::Actor *arg1 = 0 ;
95573   int arg2 ;
95574   std::vector< Dali::Actor > *result = 0 ;
95575
95576   arg1 = (Dali::Actor *)jarg1;
95577   if (!arg1) {
95578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95579     return 0;
95580   }
95581   arg2 = (int)jarg2;
95582   {
95583     try {
95584       try {
95585         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95586       }
95587       catch(std::out_of_range &_e) {
95588         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95589         return 0;
95590       }
95591
95592     } catch (std::out_of_range& e) {
95593       {
95594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95595       };
95596     } catch (std::exception& e) {
95597       {
95598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95599       };
95600     } catch (Dali::DaliException e) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95603       };
95604     } catch (...) {
95605       {
95606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95607       };
95608     }
95609   }
95610
95611   jresult = (void *)result;
95612   return jresult;
95613 }
95614
95615
95616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95617   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95618
95619   arg1 = (std::vector< Dali::Actor > *)jarg1;
95620   {
95621     try {
95622       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95623     } catch (std::out_of_range& e) {
95624       {
95625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95626       };
95627     } catch (std::exception& e) {
95628       {
95629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95630       };
95631     } catch (Dali::DaliException e) {
95632       {
95633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95634       };
95635     } catch (...) {
95636       {
95637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95638       };
95639     }
95640   }
95641
95642 }
95643
95644
95645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95646   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95647   int arg2 ;
95648   int arg3 ;
95649
95650   arg1 = (std::vector< Dali::Actor > *)jarg1;
95651   arg2 = (int)jarg2;
95652   arg3 = (int)jarg3;
95653   {
95654     try {
95655       try {
95656         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95657       }
95658       catch(std::out_of_range &_e) {
95659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95660         return ;
95661       }
95662       catch(std::invalid_argument &_e) {
95663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95664         return ;
95665       }
95666
95667     } catch (std::out_of_range& e) {
95668       {
95669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95670       };
95671     } catch (std::exception& e) {
95672       {
95673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95674       };
95675     } catch (Dali::DaliException e) {
95676       {
95677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95678       };
95679     } catch (...) {
95680       {
95681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95682       };
95683     }
95684   }
95685
95686 }
95687
95688
95689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95690   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95691   int arg2 ;
95692   std::vector< Dali::Actor > *arg3 = 0 ;
95693
95694   arg1 = (std::vector< Dali::Actor > *)jarg1;
95695   arg2 = (int)jarg2;
95696   arg3 = (std::vector< Dali::Actor > *)jarg3;
95697   if (!arg3) {
95698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95699     return ;
95700   }
95701   {
95702     try {
95703       try {
95704         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95705       }
95706       catch(std::out_of_range &_e) {
95707         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95708         return ;
95709       }
95710
95711     } catch (std::out_of_range& e) {
95712       {
95713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95714       };
95715     } catch (std::exception& e) {
95716       {
95717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95718       };
95719     } catch (Dali::DaliException e) {
95720       {
95721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95722       };
95723     } catch (...) {
95724       {
95725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95726       };
95727     }
95728   }
95729
95730 }
95731
95732
95733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95734   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95735
95736   arg1 = (std::vector< Dali::Actor > *)jarg1;
95737   {
95738     try {
95739       delete arg1;
95740     } catch (std::out_of_range& e) {
95741       {
95742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95743       };
95744     } catch (std::exception& e) {
95745       {
95746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95747       };
95748     } catch (Dali::DaliException e) {
95749       {
95750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95751       };
95752     } catch (...) {
95753       {
95754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95755       };
95756     }
95757   }
95758
95759 }
95760
95761
95762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95763   unsigned int jresult ;
95764   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95765   bool result;
95766
95767   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95768   {
95769     try {
95770       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95771     } catch (std::out_of_range& e) {
95772       {
95773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95774       };
95775     } catch (std::exception& e) {
95776       {
95777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95778       };
95779     } catch (Dali::DaliException e) {
95780       {
95781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95782       };
95783     } catch (...) {
95784       {
95785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95786       };
95787     }
95788   }
95789
95790   jresult = result;
95791   return jresult;
95792 }
95793
95794
95795 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95796   unsigned long jresult ;
95797   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95798   std::size_t result;
95799
95800   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95801   {
95802     try {
95803       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95804     } catch (std::out_of_range& e) {
95805       {
95806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95807       };
95808     } catch (std::exception& e) {
95809       {
95810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95811       };
95812     } catch (Dali::DaliException e) {
95813       {
95814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95815       };
95816     } catch (...) {
95817       {
95818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95819       };
95820     }
95821   }
95822
95823   jresult = (unsigned long)result;
95824   return jresult;
95825 }
95826
95827
95828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95829   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95830   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95831
95832   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95833   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95834   {
95835     try {
95836       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95837     } catch (std::out_of_range& e) {
95838       {
95839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95840       };
95841     } catch (std::exception& e) {
95842       {
95843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95844       };
95845     } catch (Dali::DaliException e) {
95846       {
95847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95848       };
95849     } catch (...) {
95850       {
95851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95852       };
95853     }
95854   }
95855
95856 }
95857
95858
95859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95860   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95861   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95862
95863   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95864   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95865   {
95866     try {
95867       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95868     } catch (std::out_of_range& e) {
95869       {
95870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95871       };
95872     } catch (std::exception& e) {
95873       {
95874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95875       };
95876     } catch (Dali::DaliException e) {
95877       {
95878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95879       };
95880     } catch (...) {
95881       {
95882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95883       };
95884     }
95885   }
95886
95887 }
95888
95889
95890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95891   unsigned int jresult ;
95892   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95893   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95894   bool result;
95895
95896   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95897   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95898   if (!arg2) {
95899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95900     return 0;
95901   }
95902   {
95903     try {
95904       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95905     } catch (std::out_of_range& e) {
95906       {
95907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95908       };
95909     } catch (std::exception& e) {
95910       {
95911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95912       };
95913     } catch (Dali::DaliException e) {
95914       {
95915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95916       };
95917     } catch (...) {
95918       {
95919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95920       };
95921     }
95922   }
95923
95924   jresult = result;
95925   return jresult;
95926 }
95927
95928
95929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95930   void * jresult ;
95931   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95932
95933   {
95934     try {
95935       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95936     } catch (std::out_of_range& e) {
95937       {
95938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95939       };
95940     } catch (std::exception& e) {
95941       {
95942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95943       };
95944     } catch (Dali::DaliException e) {
95945       {
95946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95947       };
95948     } catch (...) {
95949       {
95950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95951       };
95952     }
95953   }
95954
95955   jresult = (void *)result;
95956   return jresult;
95957 }
95958
95959
95960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95961   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95962
95963   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95964   {
95965     try {
95966       delete arg1;
95967     } catch (std::out_of_range& e) {
95968       {
95969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95970       };
95971     } catch (std::exception& e) {
95972       {
95973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95974       };
95975     } catch (Dali::DaliException e) {
95976       {
95977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95978       };
95979     } catch (...) {
95980       {
95981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95982       };
95983     }
95984   }
95985
95986 }
95987
95988
95989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95990   unsigned int jresult ;
95991   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95992   bool result;
95993
95994   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95995   {
95996     try {
95997       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);
95998     } catch (std::out_of_range& e) {
95999       {
96000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96001       };
96002     } catch (std::exception& e) {
96003       {
96004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96005       };
96006     } catch (Dali::DaliException e) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96009       };
96010     } catch (...) {
96011       {
96012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96013       };
96014     }
96015   }
96016
96017   jresult = result;
96018   return jresult;
96019 }
96020
96021
96022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96023   unsigned long jresult ;
96024   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96025   std::size_t result;
96026
96027   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96028   {
96029     try {
96030       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);
96031     } catch (std::out_of_range& e) {
96032       {
96033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96034       };
96035     } catch (std::exception& e) {
96036       {
96037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96038       };
96039     } catch (Dali::DaliException e) {
96040       {
96041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96042       };
96043     } catch (...) {
96044       {
96045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96046       };
96047     }
96048   }
96049
96050   jresult = (unsigned long)result;
96051   return jresult;
96052 }
96053
96054
96055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96056   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96057   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96058
96059   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96060   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96061   {
96062     try {
96063       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96064     } catch (std::out_of_range& e) {
96065       {
96066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96067       };
96068     } catch (std::exception& e) {
96069       {
96070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96071       };
96072     } catch (Dali::DaliException e) {
96073       {
96074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96075       };
96076     } catch (...) {
96077       {
96078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96079       };
96080     }
96081   }
96082
96083 }
96084
96085
96086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96087   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96088   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96089
96090   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96091   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96092   {
96093     try {
96094       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96095     } catch (std::out_of_range& e) {
96096       {
96097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96098       };
96099     } catch (std::exception& e) {
96100       {
96101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96102       };
96103     } catch (Dali::DaliException e) {
96104       {
96105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96106       };
96107     } catch (...) {
96108       {
96109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96110       };
96111     }
96112   }
96113
96114 }
96115
96116
96117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96118   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96119   Dali::Actor arg2 ;
96120   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96121   Dali::Actor *argp2 ;
96122
96123   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96124   argp2 = (Dali::Actor *)jarg2;
96125   if (!argp2) {
96126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96127     return ;
96128   }
96129   arg2 = *argp2;
96130   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96131   {
96132     try {
96133       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96134     } catch (std::out_of_range& e) {
96135       {
96136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96137       };
96138     } catch (std::exception& e) {
96139       {
96140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96141       };
96142     } catch (Dali::DaliException e) {
96143       {
96144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96145       };
96146     } catch (...) {
96147       {
96148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96149       };
96150     }
96151   }
96152
96153 }
96154
96155
96156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96157   void * jresult ;
96158   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96159
96160   {
96161     try {
96162       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96163     } catch (std::out_of_range& e) {
96164       {
96165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96166       };
96167     } catch (std::exception& e) {
96168       {
96169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96170       };
96171     } catch (Dali::DaliException e) {
96172       {
96173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96174       };
96175     } catch (...) {
96176       {
96177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96178       };
96179     }
96180   }
96181
96182   jresult = (void *)result;
96183   return jresult;
96184 }
96185
96186
96187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96188   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96189
96190   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96191   {
96192     try {
96193       delete arg1;
96194     } catch (std::out_of_range& e) {
96195       {
96196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96197       };
96198     } catch (std::exception& e) {
96199       {
96200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96201       };
96202     } catch (Dali::DaliException e) {
96203       {
96204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96205       };
96206     } catch (...) {
96207       {
96208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96209       };
96210     }
96211   }
96212
96213 }
96214
96215
96216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96217   unsigned int jresult ;
96218   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96219   bool result;
96220
96221   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96222   {
96223     try {
96224       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96225     } catch (std::out_of_range& e) {
96226       {
96227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96228       };
96229     } catch (std::exception& e) {
96230       {
96231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96232       };
96233     } catch (Dali::DaliException e) {
96234       {
96235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96236       };
96237     } catch (...) {
96238       {
96239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96240       };
96241     }
96242   }
96243
96244   jresult = result;
96245   return jresult;
96246 }
96247
96248
96249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96250   unsigned long jresult ;
96251   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96252   std::size_t result;
96253
96254   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96255   {
96256     try {
96257       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96258     } catch (std::out_of_range& e) {
96259       {
96260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96261       };
96262     } catch (std::exception& e) {
96263       {
96264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96265       };
96266     } catch (Dali::DaliException e) {
96267       {
96268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96269       };
96270     } catch (...) {
96271       {
96272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96273       };
96274     }
96275   }
96276
96277   jresult = (unsigned long)result;
96278   return jresult;
96279 }
96280
96281
96282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96283   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96284   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96285
96286   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96287   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96288   {
96289     try {
96290       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96291     } catch (std::out_of_range& e) {
96292       {
96293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96294       };
96295     } catch (std::exception& e) {
96296       {
96297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96298       };
96299     } catch (Dali::DaliException e) {
96300       {
96301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96302       };
96303     } catch (...) {
96304       {
96305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96306       };
96307     }
96308   }
96309
96310 }
96311
96312
96313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96314   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96315   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96316
96317   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96318   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96319   {
96320     try {
96321       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96322     } catch (std::out_of_range& e) {
96323       {
96324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96325       };
96326     } catch (std::exception& e) {
96327       {
96328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96329       };
96330     } catch (Dali::DaliException e) {
96331       {
96332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96333       };
96334     } catch (...) {
96335       {
96336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96337       };
96338     }
96339   }
96340
96341 }
96342
96343
96344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96345   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96346   Dali::Actor arg2 ;
96347   Dali::Actor arg3 ;
96348   Dali::Actor *argp2 ;
96349   Dali::Actor *argp3 ;
96350
96351   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96352   argp2 = (Dali::Actor *)jarg2;
96353   if (!argp2) {
96354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96355     return ;
96356   }
96357   arg2 = *argp2;
96358   argp3 = (Dali::Actor *)jarg3;
96359   if (!argp3) {
96360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96361     return ;
96362   }
96363   arg3 = *argp3;
96364   {
96365     try {
96366       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96367     } catch (std::out_of_range& e) {
96368       {
96369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96370       };
96371     } catch (std::exception& e) {
96372       {
96373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96374       };
96375     } catch (Dali::DaliException e) {
96376       {
96377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96378       };
96379     } catch (...) {
96380       {
96381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96382       };
96383     }
96384   }
96385
96386 }
96387
96388
96389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96390   void * jresult ;
96391   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96392
96393   {
96394     try {
96395       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96396     } catch (std::out_of_range& e) {
96397       {
96398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96399       };
96400     } catch (std::exception& e) {
96401       {
96402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96403       };
96404     } catch (Dali::DaliException e) {
96405       {
96406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96407       };
96408     } catch (...) {
96409       {
96410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96411       };
96412     }
96413   }
96414
96415   jresult = (void *)result;
96416   return jresult;
96417 }
96418
96419
96420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96421   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96422
96423   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96424   {
96425     try {
96426       delete arg1;
96427     } catch (std::out_of_range& e) {
96428       {
96429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96430       };
96431     } catch (std::exception& e) {
96432       {
96433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96434       };
96435     } catch (Dali::DaliException e) {
96436       {
96437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96438       };
96439     } catch (...) {
96440       {
96441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96442       };
96443     }
96444   }
96445
96446 }
96447
96448
96449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96450   unsigned int jresult ;
96451   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96452   bool result;
96453
96454   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96455   {
96456     try {
96457       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96458     } catch (std::out_of_range& e) {
96459       {
96460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96461       };
96462     } catch (std::exception& e) {
96463       {
96464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96465       };
96466     } catch (Dali::DaliException e) {
96467       {
96468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96469       };
96470     } catch (...) {
96471       {
96472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96473       };
96474     }
96475   }
96476
96477   jresult = result;
96478   return jresult;
96479 }
96480
96481
96482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96483   unsigned long jresult ;
96484   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96485   std::size_t result;
96486
96487   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96488   {
96489     try {
96490       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96491     } catch (std::out_of_range& e) {
96492       {
96493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96494       };
96495     } catch (std::exception& e) {
96496       {
96497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96498       };
96499     } catch (Dali::DaliException e) {
96500       {
96501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96502       };
96503     } catch (...) {
96504       {
96505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96506       };
96507     }
96508   }
96509
96510   jresult = (unsigned long)result;
96511   return jresult;
96512 }
96513
96514
96515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96516   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96517   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96518
96519   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96520   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96521   {
96522     try {
96523       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96524     } catch (std::out_of_range& e) {
96525       {
96526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96527       };
96528     } catch (std::exception& e) {
96529       {
96530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96531       };
96532     } catch (Dali::DaliException e) {
96533       {
96534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96535       };
96536     } catch (...) {
96537       {
96538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96539       };
96540     }
96541   }
96542
96543 }
96544
96545
96546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96547   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96548   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96549
96550   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96551   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96552   {
96553     try {
96554       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96555     } catch (std::out_of_range& e) {
96556       {
96557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96558       };
96559     } catch (std::exception& e) {
96560       {
96561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96562       };
96563     } catch (Dali::DaliException e) {
96564       {
96565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96566       };
96567     } catch (...) {
96568       {
96569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96570       };
96571     }
96572   }
96573
96574 }
96575
96576
96577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96578   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96579   Dali::Actor arg2 ;
96580   bool arg3 ;
96581   Dali::Actor *argp2 ;
96582
96583   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96584   argp2 = (Dali::Actor *)jarg2;
96585   if (!argp2) {
96586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96587     return ;
96588   }
96589   arg2 = *argp2;
96590   arg3 = jarg3 ? true : false;
96591   {
96592     try {
96593       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96594     } catch (std::out_of_range& e) {
96595       {
96596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96597       };
96598     } catch (std::exception& e) {
96599       {
96600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96601       };
96602     } catch (Dali::DaliException e) {
96603       {
96604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96605       };
96606     } catch (...) {
96607       {
96608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96609       };
96610     }
96611   }
96612
96613 }
96614
96615
96616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96617   void * jresult ;
96618   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96619
96620   {
96621     try {
96622       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96623     } catch (std::out_of_range& e) {
96624       {
96625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96626       };
96627     } catch (std::exception& e) {
96628       {
96629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96630       };
96631     } catch (Dali::DaliException e) {
96632       {
96633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96634       };
96635     } catch (...) {
96636       {
96637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96638       };
96639     }
96640   }
96641
96642   jresult = (void *)result;
96643   return jresult;
96644 }
96645
96646
96647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96648   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96649
96650   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96651   {
96652     try {
96653       delete arg1;
96654     } catch (std::out_of_range& e) {
96655       {
96656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96657       };
96658     } catch (std::exception& e) {
96659       {
96660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96661       };
96662     } catch (Dali::DaliException e) {
96663       {
96664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96665       };
96666     } catch (...) {
96667       {
96668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96669       };
96670     }
96671   }
96672
96673 }
96674
96675
96676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96677   unsigned int jresult ;
96678   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96679   bool result;
96680
96681   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96682   {
96683     try {
96684       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);
96685     } catch (std::out_of_range& e) {
96686       {
96687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96688       };
96689     } catch (std::exception& e) {
96690       {
96691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96692       };
96693     } catch (Dali::DaliException e) {
96694       {
96695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96696       };
96697     } catch (...) {
96698       {
96699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96700       };
96701     }
96702   }
96703
96704   jresult = result;
96705   return jresult;
96706 }
96707
96708
96709 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96710   unsigned long jresult ;
96711   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96712   std::size_t result;
96713
96714   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96715   {
96716     try {
96717       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);
96718     } catch (std::out_of_range& e) {
96719       {
96720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96721       };
96722     } catch (std::exception& e) {
96723       {
96724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96725       };
96726     } catch (Dali::DaliException e) {
96727       {
96728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96729       };
96730     } catch (...) {
96731       {
96732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96733       };
96734     }
96735   }
96736
96737   jresult = (unsigned long)result;
96738   return jresult;
96739 }
96740
96741
96742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96743   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96744   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96745
96746   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96747   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96748   {
96749     try {
96750       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96751     } catch (std::out_of_range& e) {
96752       {
96753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96754       };
96755     } catch (std::exception& e) {
96756       {
96757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96758       };
96759     } catch (Dali::DaliException e) {
96760       {
96761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96762       };
96763     } catch (...) {
96764       {
96765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96766       };
96767     }
96768   }
96769
96770 }
96771
96772
96773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96774   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96775   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96776
96777   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96778   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96779   {
96780     try {
96781       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96782     } catch (std::out_of_range& e) {
96783       {
96784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96785       };
96786     } catch (std::exception& e) {
96787       {
96788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96789       };
96790     } catch (Dali::DaliException e) {
96791       {
96792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96793       };
96794     } catch (...) {
96795       {
96796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96797       };
96798     }
96799   }
96800
96801 }
96802
96803
96804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96805   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96806   Dali::Toolkit::StyleManager arg2 ;
96807   Dali::StyleChange::Type arg3 ;
96808   Dali::Toolkit::StyleManager *argp2 ;
96809
96810   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96811   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96812   if (!argp2) {
96813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96814     return ;
96815   }
96816   arg2 = *argp2;
96817   arg3 = (Dali::StyleChange::Type)jarg3;
96818   {
96819     try {
96820       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96821     } catch (std::out_of_range& e) {
96822       {
96823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96824       };
96825     } catch (std::exception& e) {
96826       {
96827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96828       };
96829     } catch (Dali::DaliException e) {
96830       {
96831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96832       };
96833     } catch (...) {
96834       {
96835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96836       };
96837     }
96838   }
96839
96840 }
96841
96842
96843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96844   void * jresult ;
96845   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96846
96847   {
96848     try {
96849       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96850     } catch (std::out_of_range& e) {
96851       {
96852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96853       };
96854     } catch (std::exception& e) {
96855       {
96856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96857       };
96858     } catch (Dali::DaliException e) {
96859       {
96860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96861       };
96862     } catch (...) {
96863       {
96864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96865       };
96866     }
96867   }
96868
96869   jresult = (void *)result;
96870   return jresult;
96871 }
96872
96873
96874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96875   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96876
96877   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96878   {
96879     try {
96880       delete arg1;
96881     } catch (std::out_of_range& e) {
96882       {
96883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96884       };
96885     } catch (std::exception& e) {
96886       {
96887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96888       };
96889     } catch (Dali::DaliException e) {
96890       {
96891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96892       };
96893     } catch (...) {
96894       {
96895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96896       };
96897     }
96898   }
96899
96900 }
96901
96902
96903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96904   unsigned int jresult ;
96905   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96906   bool result;
96907
96908   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96909   {
96910     try {
96911       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96912     } catch (std::out_of_range& e) {
96913       {
96914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96915       };
96916     } catch (std::exception& e) {
96917       {
96918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96919       };
96920     } catch (Dali::DaliException e) {
96921       {
96922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96923       };
96924     } catch (...) {
96925       {
96926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96927       };
96928     }
96929   }
96930
96931   jresult = result;
96932   return jresult;
96933 }
96934
96935
96936 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96937   unsigned long jresult ;
96938   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96939   std::size_t result;
96940
96941   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96942   {
96943     try {
96944       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96945     } catch (std::out_of_range& e) {
96946       {
96947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96948       };
96949     } catch (std::exception& e) {
96950       {
96951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96952       };
96953     } catch (Dali::DaliException e) {
96954       {
96955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96956       };
96957     } catch (...) {
96958       {
96959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96960       };
96961     }
96962   }
96963
96964   jresult = (unsigned long)result;
96965   return jresult;
96966 }
96967
96968
96969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96970   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96971   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96972
96973   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96974   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96975   {
96976     try {
96977       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96978     } catch (std::out_of_range& e) {
96979       {
96980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96981       };
96982     } catch (std::exception& e) {
96983       {
96984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96985       };
96986     } catch (Dali::DaliException e) {
96987       {
96988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96989       };
96990     } catch (...) {
96991       {
96992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96993       };
96994     }
96995   }
96996
96997 }
96998
96999
97000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97001   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97002   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97003
97004   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97005   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97006   {
97007     try {
97008       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97009     } catch (std::out_of_range& e) {
97010       {
97011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97012       };
97013     } catch (std::exception& e) {
97014       {
97015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97016       };
97017     } catch (Dali::DaliException e) {
97018       {
97019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97020       };
97021     } catch (...) {
97022       {
97023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97024       };
97025     }
97026   }
97027
97028 }
97029
97030
97031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97032   unsigned int jresult ;
97033   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97034   Dali::Toolkit::Button arg2 ;
97035   Dali::Toolkit::Button *argp2 ;
97036   bool result;
97037
97038   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97039   argp2 = (Dali::Toolkit::Button *)jarg2;
97040   if (!argp2) {
97041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97042     return 0;
97043   }
97044   arg2 = *argp2;
97045   {
97046     try {
97047       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97048     } catch (std::out_of_range& e) {
97049       {
97050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97051       };
97052     } catch (std::exception& e) {
97053       {
97054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97055       };
97056     } catch (Dali::DaliException e) {
97057       {
97058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97059       };
97060     } catch (...) {
97061       {
97062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97063       };
97064     }
97065   }
97066
97067   jresult = result;
97068   return jresult;
97069 }
97070
97071
97072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97073   void * jresult ;
97074   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97075
97076   {
97077     try {
97078       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97079     } catch (std::out_of_range& e) {
97080       {
97081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97082       };
97083     } catch (std::exception& e) {
97084       {
97085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97086       };
97087     } catch (Dali::DaliException e) {
97088       {
97089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97090       };
97091     } catch (...) {
97092       {
97093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97094       };
97095     }
97096   }
97097
97098   jresult = (void *)result;
97099   return jresult;
97100 }
97101
97102
97103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97104   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97105
97106   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97107   {
97108     try {
97109       delete arg1;
97110     } catch (std::out_of_range& e) {
97111       {
97112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97113       };
97114     } catch (std::exception& e) {
97115       {
97116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97117       };
97118     } catch (Dali::DaliException e) {
97119       {
97120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97121       };
97122     } catch (...) {
97123       {
97124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97125       };
97126     }
97127   }
97128
97129 }
97130
97131
97132 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97133   unsigned int jresult ;
97134   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97135   bool result;
97136
97137   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97138   {
97139     try {
97140       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97141     } catch (std::out_of_range& e) {
97142       {
97143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97144       };
97145     } catch (std::exception& e) {
97146       {
97147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97148       };
97149     } catch (Dali::DaliException e) {
97150       {
97151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97152       };
97153     } catch (...) {
97154       {
97155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97156       };
97157     }
97158   }
97159
97160   jresult = result;
97161   return jresult;
97162 }
97163
97164
97165 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97166   unsigned long jresult ;
97167   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97168   std::size_t result;
97169
97170   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97171   {
97172     try {
97173       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97174     } catch (std::out_of_range& e) {
97175       {
97176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97177       };
97178     } catch (std::exception& e) {
97179       {
97180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97181       };
97182     } catch (Dali::DaliException e) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97185       };
97186     } catch (...) {
97187       {
97188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97189       };
97190     }
97191   }
97192
97193   jresult = (unsigned long)result;
97194   return jresult;
97195 }
97196
97197
97198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97199   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97200   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97201
97202   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97203   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97204   {
97205     try {
97206       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97207     } catch (std::out_of_range& e) {
97208       {
97209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97210       };
97211     } catch (std::exception& e) {
97212       {
97213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97214       };
97215     } catch (Dali::DaliException e) {
97216       {
97217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97218       };
97219     } catch (...) {
97220       {
97221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97222       };
97223     }
97224   }
97225
97226 }
97227
97228
97229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97230   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97231   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97232
97233   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97234   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97235   {
97236     try {
97237       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97238     } catch (std::out_of_range& e) {
97239       {
97240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97241       };
97242     } catch (std::exception& e) {
97243       {
97244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97245       };
97246     } catch (Dali::DaliException e) {
97247       {
97248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97249       };
97250     } catch (...) {
97251       {
97252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97253       };
97254     }
97255   }
97256
97257 }
97258
97259
97260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97261   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97262   Dali::Toolkit::GaussianBlurView arg2 ;
97263   Dali::Toolkit::GaussianBlurView *argp2 ;
97264
97265   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97266   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97267   if (!argp2) {
97268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97269     return ;
97270   }
97271   arg2 = *argp2;
97272   {
97273     try {
97274       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97275     } catch (std::out_of_range& e) {
97276       {
97277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97278       };
97279     } catch (std::exception& e) {
97280       {
97281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97282       };
97283     } catch (Dali::DaliException e) {
97284       {
97285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97286       };
97287     } catch (...) {
97288       {
97289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97290       };
97291     }
97292   }
97293
97294 }
97295
97296
97297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97298   void * jresult ;
97299   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97300
97301   {
97302     try {
97303       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97304     } catch (std::out_of_range& e) {
97305       {
97306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97307       };
97308     } catch (std::exception& e) {
97309       {
97310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97311       };
97312     } catch (Dali::DaliException e) {
97313       {
97314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97315       };
97316     } catch (...) {
97317       {
97318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97319       };
97320     }
97321   }
97322
97323   jresult = (void *)result;
97324   return jresult;
97325 }
97326
97327
97328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97329   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97330
97331   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97332   {
97333     try {
97334       delete arg1;
97335     } catch (std::out_of_range& e) {
97336       {
97337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97338       };
97339     } catch (std::exception& e) {
97340       {
97341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97342       };
97343     } catch (Dali::DaliException e) {
97344       {
97345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97346       };
97347     } catch (...) {
97348       {
97349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97350       };
97351     }
97352   }
97353
97354 }
97355
97356
97357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97358   unsigned int jresult ;
97359   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97360   bool result;
97361
97362   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97363   {
97364     try {
97365       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);
97366     } catch (std::out_of_range& e) {
97367       {
97368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97369       };
97370     } catch (std::exception& e) {
97371       {
97372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97373       };
97374     } catch (Dali::DaliException e) {
97375       {
97376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97377       };
97378     } catch (...) {
97379       {
97380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97381       };
97382     }
97383   }
97384
97385   jresult = result;
97386   return jresult;
97387 }
97388
97389
97390 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97391   unsigned long jresult ;
97392   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97393   std::size_t result;
97394
97395   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97396   {
97397     try {
97398       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);
97399     } catch (std::out_of_range& e) {
97400       {
97401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97402       };
97403     } catch (std::exception& e) {
97404       {
97405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97406       };
97407     } catch (Dali::DaliException e) {
97408       {
97409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97410       };
97411     } catch (...) {
97412       {
97413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97414       };
97415     }
97416   }
97417
97418   jresult = (unsigned long)result;
97419   return jresult;
97420 }
97421
97422
97423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97424   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97425   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97426
97427   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97428   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97429   {
97430     try {
97431       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97432     } catch (std::out_of_range& e) {
97433       {
97434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97435       };
97436     } catch (std::exception& e) {
97437       {
97438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97439       };
97440     } catch (Dali::DaliException e) {
97441       {
97442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97443       };
97444     } catch (...) {
97445       {
97446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97447       };
97448     }
97449   }
97450
97451 }
97452
97453
97454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97455   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97456   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97457
97458   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97459   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97460   {
97461     try {
97462       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97463     } catch (std::out_of_range& e) {
97464       {
97465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97466       };
97467     } catch (std::exception& e) {
97468       {
97469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97470       };
97471     } catch (Dali::DaliException e) {
97472       {
97473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97474       };
97475     } catch (...) {
97476       {
97477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97478       };
97479     }
97480   }
97481
97482 }
97483
97484
97485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97486   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97487   Dali::Toolkit::PageTurnView arg2 ;
97488   unsigned int arg3 ;
97489   bool arg4 ;
97490   Dali::Toolkit::PageTurnView *argp2 ;
97491
97492   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97493   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97494   if (!argp2) {
97495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97496     return ;
97497   }
97498   arg2 = *argp2;
97499   arg3 = (unsigned int)jarg3;
97500   arg4 = jarg4 ? true : false;
97501   {
97502     try {
97503       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97504     } catch (std::out_of_range& e) {
97505       {
97506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97507       };
97508     } catch (std::exception& e) {
97509       {
97510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97511       };
97512     } catch (Dali::DaliException e) {
97513       {
97514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97515       };
97516     } catch (...) {
97517       {
97518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97519       };
97520     }
97521   }
97522
97523 }
97524
97525
97526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97527   void * jresult ;
97528   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97529
97530   {
97531     try {
97532       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97533     } catch (std::out_of_range& e) {
97534       {
97535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97536       };
97537     } catch (std::exception& e) {
97538       {
97539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97540       };
97541     } catch (Dali::DaliException e) {
97542       {
97543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97544       };
97545     } catch (...) {
97546       {
97547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97548       };
97549     }
97550   }
97551
97552   jresult = (void *)result;
97553   return jresult;
97554 }
97555
97556
97557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97558   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97559
97560   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97561   {
97562     try {
97563       delete arg1;
97564     } catch (std::out_of_range& e) {
97565       {
97566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97567       };
97568     } catch (std::exception& e) {
97569       {
97570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97571       };
97572     } catch (Dali::DaliException e) {
97573       {
97574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97575       };
97576     } catch (...) {
97577       {
97578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97579       };
97580     }
97581   }
97582
97583 }
97584
97585
97586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97587   unsigned int jresult ;
97588   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97589   bool result;
97590
97591   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97592   {
97593     try {
97594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97595     } catch (std::out_of_range& e) {
97596       {
97597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97598       };
97599     } catch (std::exception& e) {
97600       {
97601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97602       };
97603     } catch (Dali::DaliException e) {
97604       {
97605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97606       };
97607     } catch (...) {
97608       {
97609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97610       };
97611     }
97612   }
97613
97614   jresult = result;
97615   return jresult;
97616 }
97617
97618
97619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97620   unsigned long jresult ;
97621   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97622   std::size_t result;
97623
97624   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97625   {
97626     try {
97627       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97628     } catch (std::out_of_range& e) {
97629       {
97630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97631       };
97632     } catch (std::exception& e) {
97633       {
97634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97635       };
97636     } catch (Dali::DaliException e) {
97637       {
97638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97639       };
97640     } catch (...) {
97641       {
97642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97643       };
97644     }
97645   }
97646
97647   jresult = (unsigned long)result;
97648   return jresult;
97649 }
97650
97651
97652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97653   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97654   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97655
97656   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97657   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97658   {
97659     try {
97660       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97661     } catch (std::out_of_range& e) {
97662       {
97663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97664       };
97665     } catch (std::exception& e) {
97666       {
97667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97668       };
97669     } catch (Dali::DaliException e) {
97670       {
97671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97672       };
97673     } catch (...) {
97674       {
97675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97676       };
97677     }
97678   }
97679
97680 }
97681
97682
97683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97684   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97685   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97686
97687   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97688   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97689   {
97690     try {
97691       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97692     } catch (std::out_of_range& e) {
97693       {
97694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97695       };
97696     } catch (std::exception& e) {
97697       {
97698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97699       };
97700     } catch (Dali::DaliException e) {
97701       {
97702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97703       };
97704     } catch (...) {
97705       {
97706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97707       };
97708     }
97709   }
97710
97711 }
97712
97713
97714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97715   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97716   Dali::Toolkit::PageTurnView arg2 ;
97717   Dali::Toolkit::PageTurnView *argp2 ;
97718
97719   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97720   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97721   if (!argp2) {
97722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97723     return ;
97724   }
97725   arg2 = *argp2;
97726   {
97727     try {
97728       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97729     } catch (std::out_of_range& e) {
97730       {
97731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97732       };
97733     } catch (std::exception& e) {
97734       {
97735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97736       };
97737     } catch (Dali::DaliException e) {
97738       {
97739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97740       };
97741     } catch (...) {
97742       {
97743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97744       };
97745     }
97746   }
97747
97748 }
97749
97750
97751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97752   void * jresult ;
97753   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97754
97755   {
97756     try {
97757       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97758     } catch (std::out_of_range& e) {
97759       {
97760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97761       };
97762     } catch (std::exception& e) {
97763       {
97764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97765       };
97766     } catch (Dali::DaliException e) {
97767       {
97768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97769       };
97770     } catch (...) {
97771       {
97772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97773       };
97774     }
97775   }
97776
97777   jresult = (void *)result;
97778   return jresult;
97779 }
97780
97781
97782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97783   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97784
97785   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97786   {
97787     try {
97788       delete arg1;
97789     } catch (std::out_of_range& e) {
97790       {
97791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97792       };
97793     } catch (std::exception& e) {
97794       {
97795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97796       };
97797     } catch (Dali::DaliException e) {
97798       {
97799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97800       };
97801     } catch (...) {
97802       {
97803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97804       };
97805     }
97806   }
97807
97808 }
97809
97810
97811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97812   unsigned int jresult ;
97813   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97814   bool result;
97815
97816   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97817   {
97818     try {
97819       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);
97820     } catch (std::out_of_range& e) {
97821       {
97822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97823       };
97824     } catch (std::exception& e) {
97825       {
97826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97827       };
97828     } catch (Dali::DaliException e) {
97829       {
97830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97831       };
97832     } catch (...) {
97833       {
97834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97835       };
97836     }
97837   }
97838
97839   jresult = result;
97840   return jresult;
97841 }
97842
97843
97844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97845   unsigned long jresult ;
97846   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97847   std::size_t result;
97848
97849   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97850   {
97851     try {
97852       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);
97853     } catch (std::out_of_range& e) {
97854       {
97855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97856       };
97857     } catch (std::exception& e) {
97858       {
97859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97860       };
97861     } catch (Dali::DaliException e) {
97862       {
97863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97864       };
97865     } catch (...) {
97866       {
97867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97868       };
97869     }
97870   }
97871
97872   jresult = (unsigned long)result;
97873   return jresult;
97874 }
97875
97876
97877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97878   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97879   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97880
97881   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97882   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97883   {
97884     try {
97885       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97886     } catch (std::out_of_range& e) {
97887       {
97888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97889       };
97890     } catch (std::exception& e) {
97891       {
97892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97893       };
97894     } catch (Dali::DaliException e) {
97895       {
97896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97897       };
97898     } catch (...) {
97899       {
97900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97901       };
97902     }
97903   }
97904
97905 }
97906
97907
97908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97909   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97910   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97911
97912   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97913   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97914   {
97915     try {
97916       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97917     } catch (std::out_of_range& e) {
97918       {
97919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97920       };
97921     } catch (std::exception& e) {
97922       {
97923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97924       };
97925     } catch (Dali::DaliException e) {
97926       {
97927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97928       };
97929     } catch (...) {
97930       {
97931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97932       };
97933     }
97934   }
97935
97936 }
97937
97938
97939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97940   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97941   Dali::Toolkit::ProgressBar arg2 ;
97942   float arg3 ;
97943   float arg4 ;
97944   Dali::Toolkit::ProgressBar *argp2 ;
97945
97946   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97947   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97948   if (!argp2) {
97949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97950     return ;
97951   }
97952   arg2 = *argp2;
97953   arg3 = (float)jarg3;
97954   arg4 = (float)jarg4;
97955   {
97956     try {
97957       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97958     } catch (std::out_of_range& e) {
97959       {
97960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97961       };
97962     } catch (std::exception& e) {
97963       {
97964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97965       };
97966     } catch (Dali::DaliException e) {
97967       {
97968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97969       };
97970     } catch (...) {
97971       {
97972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97973       };
97974     }
97975   }
97976
97977 }
97978
97979
97980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97981   void * jresult ;
97982   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97983
97984   {
97985     try {
97986       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97987     } catch (std::out_of_range& e) {
97988       {
97989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97990       };
97991     } catch (std::exception& e) {
97992       {
97993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97994       };
97995     } catch (Dali::DaliException e) {
97996       {
97997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97998       };
97999     } catch (...) {
98000       {
98001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98002       };
98003     }
98004   }
98005
98006   jresult = (void *)result;
98007   return jresult;
98008 }
98009
98010
98011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98012   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98013
98014   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98015   {
98016     try {
98017       delete arg1;
98018     } catch (std::out_of_range& e) {
98019       {
98020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98021       };
98022     } catch (std::exception& e) {
98023       {
98024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98025       };
98026     } catch (Dali::DaliException e) {
98027       {
98028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98029       };
98030     } catch (...) {
98031       {
98032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98033       };
98034     }
98035   }
98036
98037 }
98038
98039
98040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98041   unsigned int jresult ;
98042   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98043   bool result;
98044
98045   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98046   {
98047     try {
98048       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);
98049     } catch (std::out_of_range& e) {
98050       {
98051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98052       };
98053     } catch (std::exception& e) {
98054       {
98055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98056       };
98057     } catch (Dali::DaliException e) {
98058       {
98059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98060       };
98061     } catch (...) {
98062       {
98063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98064       };
98065     }
98066   }
98067
98068   jresult = result;
98069   return jresult;
98070 }
98071
98072
98073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98074   unsigned long jresult ;
98075   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98076   std::size_t result;
98077
98078   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98079   {
98080     try {
98081       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);
98082     } catch (std::out_of_range& e) {
98083       {
98084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98085       };
98086     } catch (std::exception& e) {
98087       {
98088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98089       };
98090     } catch (Dali::DaliException e) {
98091       {
98092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98093       };
98094     } catch (...) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98097       };
98098     }
98099   }
98100
98101   jresult = (unsigned long)result;
98102   return jresult;
98103 }
98104
98105
98106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98107   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98108   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98109
98110   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98111   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98112   {
98113     try {
98114       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98115     } catch (std::out_of_range& e) {
98116       {
98117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98118       };
98119     } catch (std::exception& e) {
98120       {
98121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98122       };
98123     } catch (Dali::DaliException e) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98126       };
98127     } catch (...) {
98128       {
98129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98130       };
98131     }
98132   }
98133
98134 }
98135
98136
98137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98138   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98139   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98140
98141   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98142   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98143   {
98144     try {
98145       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98146     } catch (std::out_of_range& e) {
98147       {
98148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98149       };
98150     } catch (std::exception& e) {
98151       {
98152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98153       };
98154     } catch (Dali::DaliException e) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98157       };
98158     } catch (...) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98161       };
98162     }
98163   }
98164
98165 }
98166
98167
98168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98169   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98170   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98171
98172   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98173   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98174   if (!arg2) {
98175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98176     return ;
98177   }
98178   {
98179     try {
98180       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98181     } catch (std::out_of_range& e) {
98182       {
98183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98184       };
98185     } catch (std::exception& e) {
98186       {
98187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98188       };
98189     } catch (Dali::DaliException e) {
98190       {
98191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98192       };
98193     } catch (...) {
98194       {
98195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98196       };
98197     }
98198   }
98199
98200 }
98201
98202
98203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98204   void * jresult ;
98205   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98206
98207   {
98208     try {
98209       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98210     } catch (std::out_of_range& e) {
98211       {
98212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98213       };
98214     } catch (std::exception& e) {
98215       {
98216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98217       };
98218     } catch (Dali::DaliException e) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98221       };
98222     } catch (...) {
98223       {
98224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98225       };
98226     }
98227   }
98228
98229   jresult = (void *)result;
98230   return jresult;
98231 }
98232
98233
98234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98235   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98236
98237   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98238   {
98239     try {
98240       delete arg1;
98241     } catch (std::out_of_range& e) {
98242       {
98243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98244       };
98245     } catch (std::exception& e) {
98246       {
98247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98248       };
98249     } catch (Dali::DaliException e) {
98250       {
98251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98252       };
98253     } catch (...) {
98254       {
98255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98256       };
98257     }
98258   }
98259
98260 }
98261
98262
98263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98264   unsigned int jresult ;
98265   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98266   bool result;
98267
98268   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98269   {
98270     try {
98271       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98272     } catch (std::out_of_range& e) {
98273       {
98274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98275       };
98276     } catch (std::exception& e) {
98277       {
98278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98279       };
98280     } catch (Dali::DaliException e) {
98281       {
98282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98283       };
98284     } catch (...) {
98285       {
98286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98287       };
98288     }
98289   }
98290
98291   jresult = result;
98292   return jresult;
98293 }
98294
98295
98296 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98297   unsigned long jresult ;
98298   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98299   std::size_t result;
98300
98301   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98302   {
98303     try {
98304       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98305     } catch (std::out_of_range& e) {
98306       {
98307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98308       };
98309     } catch (std::exception& e) {
98310       {
98311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98312       };
98313     } catch (Dali::DaliException e) {
98314       {
98315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98316       };
98317     } catch (...) {
98318       {
98319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98320       };
98321     }
98322   }
98323
98324   jresult = (unsigned long)result;
98325   return jresult;
98326 }
98327
98328
98329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98330   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98331   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98332
98333   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98334   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98335   {
98336     try {
98337       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98338     } catch (std::out_of_range& e) {
98339       {
98340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98341       };
98342     } catch (std::exception& e) {
98343       {
98344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98345       };
98346     } catch (Dali::DaliException e) {
98347       {
98348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98349       };
98350     } catch (...) {
98351       {
98352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98353       };
98354     }
98355   }
98356
98357 }
98358
98359
98360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98361   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98362   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98363
98364   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98365   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98366   {
98367     try {
98368       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98369     } catch (std::out_of_range& e) {
98370       {
98371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98372       };
98373     } catch (std::exception& e) {
98374       {
98375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98376       };
98377     } catch (Dali::DaliException e) {
98378       {
98379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98380       };
98381     } catch (...) {
98382       {
98383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98384       };
98385     }
98386   }
98387
98388 }
98389
98390
98391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98392   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98393   Dali::Vector2 *arg2 = 0 ;
98394
98395   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98396   arg2 = (Dali::Vector2 *)jarg2;
98397   if (!arg2) {
98398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98399     return ;
98400   }
98401   {
98402     try {
98403       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98404     } catch (std::out_of_range& e) {
98405       {
98406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98407       };
98408     } catch (std::exception& e) {
98409       {
98410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98411       };
98412     } catch (Dali::DaliException e) {
98413       {
98414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98415       };
98416     } catch (...) {
98417       {
98418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98419       };
98420     }
98421   }
98422
98423 }
98424
98425
98426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98427   void * jresult ;
98428   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98429
98430   {
98431     try {
98432       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98433     } catch (std::out_of_range& e) {
98434       {
98435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98436       };
98437     } catch (std::exception& e) {
98438       {
98439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98440       };
98441     } catch (Dali::DaliException e) {
98442       {
98443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98444       };
98445     } catch (...) {
98446       {
98447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98448       };
98449     }
98450   }
98451
98452   jresult = (void *)result;
98453   return jresult;
98454 }
98455
98456
98457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98458   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98459
98460   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98461   {
98462     try {
98463       delete arg1;
98464     } catch (std::out_of_range& e) {
98465       {
98466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98467       };
98468     } catch (std::exception& e) {
98469       {
98470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98471       };
98472     } catch (Dali::DaliException e) {
98473       {
98474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98475       };
98476     } catch (...) {
98477       {
98478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98479       };
98480     }
98481   }
98482
98483 }
98484
98485
98486
98487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98488   unsigned int jresult ;
98489   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98490   bool result;
98491
98492   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98493   {
98494     try {
98495       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);
98496     } catch (std::out_of_range& e) {
98497       {
98498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98499       };
98500     } catch (std::exception& e) {
98501       {
98502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98503       };
98504     } catch (Dali::DaliException e) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98507       };
98508     } catch (...) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98511       };
98512     }
98513   }
98514
98515   jresult = result;
98516   return jresult;
98517 }
98518
98519
98520 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98521   unsigned long jresult ;
98522   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98523   std::size_t result;
98524
98525   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98526   {
98527     try {
98528       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);
98529     } catch (std::out_of_range& e) {
98530       {
98531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98532       };
98533     } catch (std::exception& e) {
98534       {
98535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98536       };
98537     } catch (Dali::DaliException e) {
98538       {
98539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98540       };
98541     } catch (...) {
98542       {
98543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98544       };
98545     }
98546   }
98547
98548   jresult = (unsigned long)result;
98549   return jresult;
98550 }
98551
98552
98553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98554   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98555   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98556
98557   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98558   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98559   {
98560     try {
98561       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98562     } catch (std::out_of_range& e) {
98563       {
98564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98565       };
98566     } catch (std::exception& e) {
98567       {
98568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98569       };
98570     } catch (Dali::DaliException e) {
98571       {
98572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98573       };
98574     } catch (...) {
98575       {
98576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98577       };
98578     }
98579   }
98580
98581 }
98582
98583
98584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98585   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98586   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98587
98588   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98589   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98590   {
98591     try {
98592       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98593     } catch (std::out_of_range& e) {
98594       {
98595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98596       };
98597     } catch (std::exception& e) {
98598       {
98599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98600       };
98601     } catch (Dali::DaliException e) {
98602       {
98603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98604       };
98605     } catch (...) {
98606       {
98607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98608       };
98609     }
98610   }
98611
98612 }
98613
98614
98615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98616   unsigned int jresult ;
98617   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98618   Dali::Toolkit::Control arg2 ;
98619   Dali::KeyEvent *arg3 = 0 ;
98620   Dali::Toolkit::Control *argp2 ;
98621   bool result;
98622
98623   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98624   argp2 = (Dali::Toolkit::Control *)jarg2;
98625   if (!argp2) {
98626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98627     return 0;
98628   }
98629   arg2 = *argp2;
98630   arg3 = (Dali::KeyEvent *)jarg3;
98631   if (!arg3) {
98632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98633     return 0;
98634   }
98635   {
98636     try {
98637       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);
98638     } catch (std::out_of_range& e) {
98639       {
98640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98641       };
98642     } catch (std::exception& e) {
98643       {
98644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98645       };
98646     } catch (Dali::DaliException e) {
98647       {
98648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98649       };
98650     } catch (...) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98653       };
98654     }
98655   }
98656
98657   jresult = result;
98658   return jresult;
98659 }
98660
98661
98662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98663   void * jresult ;
98664   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98665
98666   {
98667     try {
98668       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98669     } catch (std::out_of_range& e) {
98670       {
98671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98672       };
98673     } catch (std::exception& e) {
98674       {
98675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98676       };
98677     } catch (Dali::DaliException e) {
98678       {
98679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98680       };
98681     } catch (...) {
98682       {
98683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98684       };
98685     }
98686   }
98687
98688   jresult = (void *)result;
98689   return jresult;
98690 }
98691
98692
98693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98694   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98695
98696   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98697   {
98698     try {
98699       delete arg1;
98700     } catch (std::out_of_range& e) {
98701       {
98702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98703       };
98704     } catch (std::exception& e) {
98705       {
98706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98707       };
98708     } catch (Dali::DaliException e) {
98709       {
98710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98711       };
98712     } catch (...) {
98713       {
98714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98715       };
98716     }
98717   }
98718
98719 }
98720
98721
98722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98723   unsigned int jresult ;
98724   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98725   bool result;
98726
98727   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98728   {
98729     try {
98730       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98731     } catch (std::out_of_range& e) {
98732       {
98733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98734       };
98735     } catch (std::exception& e) {
98736       {
98737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98738       };
98739     } catch (Dali::DaliException e) {
98740       {
98741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98742       };
98743     } catch (...) {
98744       {
98745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98746       };
98747     }
98748   }
98749
98750   jresult = result;
98751   return jresult;
98752 }
98753
98754
98755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98756   unsigned long jresult ;
98757   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98758   std::size_t result;
98759
98760   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98761   {
98762     try {
98763       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98764     } catch (std::out_of_range& e) {
98765       {
98766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98767       };
98768     } catch (std::exception& e) {
98769       {
98770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98771       };
98772     } catch (Dali::DaliException e) {
98773       {
98774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98775       };
98776     } catch (...) {
98777       {
98778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98779       };
98780     }
98781   }
98782
98783   jresult = (unsigned long)result;
98784   return jresult;
98785 }
98786
98787
98788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98789   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98790   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98791
98792   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98793   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98794   {
98795     try {
98796       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98797     } catch (std::out_of_range& e) {
98798       {
98799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98800       };
98801     } catch (std::exception& e) {
98802       {
98803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98804       };
98805     } catch (Dali::DaliException e) {
98806       {
98807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98808       };
98809     } catch (...) {
98810       {
98811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98812       };
98813     }
98814   }
98815
98816 }
98817
98818
98819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98820   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98821   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98822
98823   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98824   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98825   {
98826     try {
98827       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98828     } catch (std::out_of_range& e) {
98829       {
98830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98831       };
98832     } catch (std::exception& e) {
98833       {
98834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98835       };
98836     } catch (Dali::DaliException e) {
98837       {
98838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98839       };
98840     } catch (...) {
98841       {
98842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98843       };
98844     }
98845   }
98846
98847 }
98848
98849
98850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98851   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98852   Dali::Toolkit::Control arg2 ;
98853   Dali::Toolkit::Control *argp2 ;
98854
98855   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98856   argp2 = (Dali::Toolkit::Control *)jarg2;
98857   if (!argp2) {
98858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98859     return ;
98860   }
98861   arg2 = *argp2;
98862   {
98863     try {
98864       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98865     } catch (std::out_of_range& e) {
98866       {
98867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98868       };
98869     } catch (std::exception& e) {
98870       {
98871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98872       };
98873     } catch (Dali::DaliException e) {
98874       {
98875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98876       };
98877     } catch (...) {
98878       {
98879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98880       };
98881     }
98882   }
98883
98884 }
98885
98886
98887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98888   void * jresult ;
98889   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98890
98891   {
98892     try {
98893       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98894     } catch (std::out_of_range& e) {
98895       {
98896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98897       };
98898     } catch (std::exception& e) {
98899       {
98900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98901       };
98902     } catch (Dali::DaliException e) {
98903       {
98904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98905       };
98906     } catch (...) {
98907       {
98908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98909       };
98910     }
98911   }
98912
98913   jresult = (void *)result;
98914   return jresult;
98915 }
98916
98917
98918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98919   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98920
98921   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98922   {
98923     try {
98924       delete arg1;
98925     } catch (std::out_of_range& e) {
98926       {
98927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98928       };
98929     } catch (std::exception& e) {
98930       {
98931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98932       };
98933     } catch (Dali::DaliException e) {
98934       {
98935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98936       };
98937     } catch (...) {
98938       {
98939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98940       };
98941     }
98942   }
98943
98944 }
98945
98946
98947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98948   unsigned int jresult ;
98949   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98950   bool result;
98951
98952   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98953   {
98954     try {
98955       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98956     } catch (std::out_of_range& e) {
98957       {
98958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98959       };
98960     } catch (std::exception& e) {
98961       {
98962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98963       };
98964     } catch (Dali::DaliException e) {
98965       {
98966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98967       };
98968     } catch (...) {
98969       {
98970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98971       };
98972     }
98973   }
98974
98975   jresult = result;
98976   return jresult;
98977 }
98978
98979
98980 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98981   unsigned long jresult ;
98982   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98983   std::size_t result;
98984
98985   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98986   {
98987     try {
98988       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98989     } catch (std::out_of_range& e) {
98990       {
98991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98992       };
98993     } catch (std::exception& e) {
98994       {
98995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98996       };
98997     } catch (Dali::DaliException e) {
98998       {
98999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99000       };
99001     } catch (...) {
99002       {
99003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99004       };
99005     }
99006   }
99007
99008   jresult = (unsigned long)result;
99009   return jresult;
99010 }
99011
99012
99013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99014   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99015   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99016
99017   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99018   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99019   {
99020     try {
99021       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99022     } catch (std::out_of_range& e) {
99023       {
99024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99025       };
99026     } catch (std::exception& e) {
99027       {
99028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99029       };
99030     } catch (Dali::DaliException e) {
99031       {
99032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99033       };
99034     } catch (...) {
99035       {
99036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99037       };
99038     }
99039   }
99040
99041 }
99042
99043
99044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99045   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99046   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99047
99048   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99049   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99050   {
99051     try {
99052       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99053     } catch (std::out_of_range& e) {
99054       {
99055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99056       };
99057     } catch (std::exception& e) {
99058       {
99059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99060       };
99061     } catch (Dali::DaliException e) {
99062       {
99063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99064       };
99065     } catch (...) {
99066       {
99067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99068       };
99069     }
99070   }
99071
99072 }
99073
99074
99075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99076   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99077   Dali::Toolkit::VideoView *arg2 = 0 ;
99078
99079   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99080   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99081   if (!arg2) {
99082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99083     return ;
99084   }
99085   {
99086     try {
99087       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99088     } catch (std::out_of_range& e) {
99089       {
99090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99091       };
99092     } catch (std::exception& e) {
99093       {
99094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99095       };
99096     } catch (Dali::DaliException e) {
99097       {
99098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99099       };
99100     } catch (...) {
99101       {
99102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99103       };
99104     }
99105   }
99106
99107 }
99108
99109
99110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99111   void * jresult ;
99112   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99113
99114   {
99115     try {
99116       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99117     } catch (std::out_of_range& e) {
99118       {
99119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99120       };
99121     } catch (std::exception& e) {
99122       {
99123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99124       };
99125     } catch (Dali::DaliException e) {
99126       {
99127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99128       };
99129     } catch (...) {
99130       {
99131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99132       };
99133     }
99134   }
99135
99136   jresult = (void *)result;
99137   return jresult;
99138 }
99139
99140
99141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99142   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99143
99144   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99145   {
99146     try {
99147       delete arg1;
99148     } catch (std::out_of_range& e) {
99149       {
99150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99151       };
99152     } catch (std::exception& e) {
99153       {
99154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99155       };
99156     } catch (Dali::DaliException e) {
99157       {
99158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99159       };
99160     } catch (...) {
99161       {
99162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99163       };
99164     }
99165   }
99166
99167 }
99168
99169
99170 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99171   unsigned int jresult ;
99172   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99173   bool result;
99174
99175   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99176   {
99177     try {
99178       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99179     } catch (std::out_of_range& e) {
99180       {
99181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99182       };
99183     } catch (std::exception& e) {
99184       {
99185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99186       };
99187     } catch (Dali::DaliException e) {
99188       {
99189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99190       };
99191     } catch (...) {
99192       {
99193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99194       };
99195     }
99196   }
99197
99198   jresult = result;
99199   return jresult;
99200 }
99201
99202
99203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99204   unsigned long jresult ;
99205   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99206   std::size_t result;
99207
99208   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99209   {
99210     try {
99211       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99212     } catch (std::out_of_range& e) {
99213       {
99214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99215       };
99216     } catch (std::exception& e) {
99217       {
99218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99219       };
99220     } catch (Dali::DaliException e) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99223       };
99224     } catch (...) {
99225       {
99226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99227       };
99228     }
99229   }
99230
99231   jresult = (unsigned long)result;
99232   return jresult;
99233 }
99234
99235
99236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99237   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99238   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99239
99240   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99241   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99242   {
99243     try {
99244       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99245     } catch (std::out_of_range& e) {
99246       {
99247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99248       };
99249     } catch (std::exception& e) {
99250       {
99251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99252       };
99253     } catch (Dali::DaliException e) {
99254       {
99255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99256       };
99257     } catch (...) {
99258       {
99259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99260       };
99261     }
99262   }
99263
99264 }
99265
99266
99267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99268   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99269   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99270
99271   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99272   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99273   {
99274     try {
99275       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99276     } catch (std::out_of_range& e) {
99277       {
99278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99279       };
99280     } catch (std::exception& e) {
99281       {
99282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99283       };
99284     } catch (Dali::DaliException e) {
99285       {
99286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99287       };
99288     } catch (...) {
99289       {
99290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99291       };
99292     }
99293   }
99294
99295 }
99296
99297
99298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99299   unsigned int jresult ;
99300   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99301   Dali::Toolkit::Slider arg2 ;
99302   float arg3 ;
99303   Dali::Toolkit::Slider *argp2 ;
99304   bool result;
99305
99306   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99307   argp2 = (Dali::Toolkit::Slider *)jarg2;
99308   if (!argp2) {
99309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99310     return 0;
99311   }
99312   arg2 = *argp2;
99313   arg3 = (float)jarg3;
99314   {
99315     try {
99316       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99317     } catch (std::out_of_range& e) {
99318       {
99319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99320       };
99321     } catch (std::exception& e) {
99322       {
99323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99324       };
99325     } catch (Dali::DaliException e) {
99326       {
99327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99328       };
99329     } catch (...) {
99330       {
99331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99332       };
99333     }
99334   }
99335
99336   jresult = result;
99337   return jresult;
99338 }
99339
99340
99341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99342   void * jresult ;
99343   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99344
99345   {
99346     try {
99347       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99348     } catch (std::out_of_range& e) {
99349       {
99350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99351       };
99352     } catch (std::exception& e) {
99353       {
99354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99355       };
99356     } catch (Dali::DaliException e) {
99357       {
99358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99359       };
99360     } catch (...) {
99361       {
99362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99363       };
99364     }
99365   }
99366
99367   jresult = (void *)result;
99368   return jresult;
99369 }
99370
99371
99372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99373   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99374
99375   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99376   {
99377     try {
99378       delete arg1;
99379     } catch (std::out_of_range& e) {
99380       {
99381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99382       };
99383     } catch (std::exception& e) {
99384       {
99385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99386       };
99387     } catch (Dali::DaliException e) {
99388       {
99389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99390       };
99391     } catch (...) {
99392       {
99393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99394       };
99395     }
99396   }
99397
99398 }
99399
99400
99401 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99402   unsigned int jresult ;
99403   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99404   bool result;
99405
99406   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99407   {
99408     try {
99409       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99410     } catch (std::out_of_range& e) {
99411       {
99412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99413       };
99414     } catch (std::exception& e) {
99415       {
99416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99417       };
99418     } catch (Dali::DaliException e) {
99419       {
99420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99421       };
99422     } catch (...) {
99423       {
99424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99425       };
99426     }
99427   }
99428
99429   jresult = result;
99430   return jresult;
99431 }
99432
99433
99434 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99435   unsigned long jresult ;
99436   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99437   std::size_t result;
99438
99439   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99440   {
99441     try {
99442       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99443     } catch (std::out_of_range& e) {
99444       {
99445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99446       };
99447     } catch (std::exception& e) {
99448       {
99449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99450       };
99451     } catch (Dali::DaliException e) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99454       };
99455     } catch (...) {
99456       {
99457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99458       };
99459     }
99460   }
99461
99462   jresult = (unsigned long)result;
99463   return jresult;
99464 }
99465
99466
99467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99468   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99469   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99470
99471   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99472   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99473   {
99474     try {
99475       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99476     } catch (std::out_of_range& e) {
99477       {
99478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99479       };
99480     } catch (std::exception& e) {
99481       {
99482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99483       };
99484     } catch (Dali::DaliException e) {
99485       {
99486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99487       };
99488     } catch (...) {
99489       {
99490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99491       };
99492     }
99493   }
99494
99495 }
99496
99497
99498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99499   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99500   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99501
99502   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99503   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99504   {
99505     try {
99506       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99507     } catch (std::out_of_range& e) {
99508       {
99509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99510       };
99511     } catch (std::exception& e) {
99512       {
99513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99514       };
99515     } catch (Dali::DaliException e) {
99516       {
99517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99518       };
99519     } catch (...) {
99520       {
99521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99522       };
99523     }
99524   }
99525
99526 }
99527
99528
99529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99530   unsigned int jresult ;
99531   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99532   Dali::Toolkit::Slider arg2 ;
99533   int arg3 ;
99534   Dali::Toolkit::Slider *argp2 ;
99535   bool result;
99536
99537   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99538   argp2 = (Dali::Toolkit::Slider *)jarg2;
99539   if (!argp2) {
99540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99541     return 0;
99542   }
99543   arg2 = *argp2;
99544   arg3 = (int)jarg3;
99545   {
99546     try {
99547       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99548     } catch (std::out_of_range& e) {
99549       {
99550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99551       };
99552     } catch (std::exception& e) {
99553       {
99554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99555       };
99556     } catch (Dali::DaliException e) {
99557       {
99558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99559       };
99560     } catch (...) {
99561       {
99562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99563       };
99564     }
99565   }
99566
99567   jresult = result;
99568   return jresult;
99569 }
99570
99571
99572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99573   void * jresult ;
99574   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99575
99576   {
99577     try {
99578       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99579     } catch (std::out_of_range& e) {
99580       {
99581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99582       };
99583     } catch (std::exception& e) {
99584       {
99585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99586       };
99587     } catch (Dali::DaliException e) {
99588       {
99589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99590       };
99591     } catch (...) {
99592       {
99593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99594       };
99595     }
99596   }
99597
99598   jresult = (void *)result;
99599   return jresult;
99600 }
99601
99602
99603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99604   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99605
99606   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99607   {
99608     try {
99609       delete arg1;
99610     } catch (std::out_of_range& e) {
99611       {
99612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99613       };
99614     } catch (std::exception& e) {
99615       {
99616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99617       };
99618     } catch (Dali::DaliException e) {
99619       {
99620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99621       };
99622     } catch (...) {
99623       {
99624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99625       };
99626     }
99627   }
99628
99629 }
99630
99631
99632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99633   void * jresult ;
99634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99635
99636   {
99637     try {
99638       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99639     } catch (std::out_of_range& e) {
99640       {
99641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99642       };
99643     } catch (std::exception& e) {
99644       {
99645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99646       };
99647     } catch (Dali::DaliException e) {
99648       {
99649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99650       };
99651     } catch (...) {
99652       {
99653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99654       };
99655     }
99656   }
99657
99658   jresult = (void *)result;
99659   return jresult;
99660 }
99661
99662
99663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99664   void * jresult ;
99665   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99666   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99667
99668   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99669   {
99670     try {
99671       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99672     } catch (std::out_of_range& e) {
99673       {
99674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99675       };
99676     } catch (std::exception& e) {
99677       {
99678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99679       };
99680     } catch (Dali::DaliException e) {
99681       {
99682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99683       };
99684     } catch (...) {
99685       {
99686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99687       };
99688     }
99689   }
99690
99691   jresult = (void *)result;
99692   return jresult;
99693 }
99694
99695
99696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99697   void * jresult ;
99698   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99699   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99700
99701   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99702   if (!arg1) {
99703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99704     return 0;
99705   }
99706   {
99707     try {
99708       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99709     } catch (std::out_of_range& e) {
99710       {
99711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99712       };
99713     } catch (std::exception& e) {
99714       {
99715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99716       };
99717     } catch (Dali::DaliException e) {
99718       {
99719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99720       };
99721     } catch (...) {
99722       {
99723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99724       };
99725     }
99726   }
99727
99728   jresult = (void *)result;
99729   return jresult;
99730 }
99731
99732
99733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99734   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99735
99736   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99737   {
99738     try {
99739       delete arg1;
99740     } catch (std::out_of_range& e) {
99741       {
99742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99743       };
99744     } catch (std::exception& e) {
99745       {
99746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99747       };
99748     } catch (Dali::DaliException e) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99751       };
99752     } catch (...) {
99753       {
99754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99755       };
99756     }
99757   }
99758
99759 }
99760
99761
99762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99763   void * jresult ;
99764   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99765   Dali::Toolkit::Ruler *result = 0 ;
99766
99767   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99768   {
99769     try {
99770       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99771     } catch (std::out_of_range& e) {
99772       {
99773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99774       };
99775     } catch (std::exception& e) {
99776       {
99777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99778       };
99779     } catch (Dali::DaliException e) {
99780       {
99781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99782       };
99783     } catch (...) {
99784       {
99785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99786       };
99787     }
99788   }
99789
99790   jresult = (void *)result;
99791   return jresult;
99792 }
99793
99794
99795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99796   void * jresult ;
99797   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99798   Dali::Toolkit::Ruler *result = 0 ;
99799
99800   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99801   {
99802     try {
99803       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99804     } catch (std::out_of_range& e) {
99805       {
99806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99807       };
99808     } catch (std::exception& e) {
99809       {
99810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99811       };
99812     } catch (Dali::DaliException e) {
99813       {
99814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99815       };
99816     } catch (...) {
99817       {
99818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99819       };
99820     }
99821   }
99822
99823   jresult = (void *)result;
99824   return jresult;
99825 }
99826
99827
99828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99829   void * jresult ;
99830   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99831   Dali::Toolkit::Ruler *result = 0 ;
99832
99833   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99834   {
99835     try {
99836       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99844       };
99845     } catch (Dali::DaliException e) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99848       };
99849     } catch (...) {
99850       {
99851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99852       };
99853     }
99854   }
99855
99856   jresult = (void *)result;
99857   return jresult;
99858 }
99859
99860
99861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99862   void * jresult ;
99863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99864   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99865   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99866
99867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99868   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99869   if (!arg2) {
99870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99871     return 0;
99872   }
99873   {
99874     try {
99875       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99876     } catch (std::out_of_range& e) {
99877       {
99878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99879       };
99880     } catch (std::exception& e) {
99881       {
99882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99883       };
99884     } catch (Dali::DaliException e) {
99885       {
99886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99887       };
99888     } catch (...) {
99889       {
99890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99891       };
99892     }
99893   }
99894
99895   jresult = (void *)result;
99896   return jresult;
99897 }
99898
99899
99900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99901   void * jresult ;
99902   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99903   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99904   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99905
99906   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99907   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99908   {
99909     try {
99910       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99911     } catch (std::out_of_range& e) {
99912       {
99913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99914       };
99915     } catch (std::exception& e) {
99916       {
99917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99918       };
99919     } catch (Dali::DaliException e) {
99920       {
99921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99922       };
99923     } catch (...) {
99924       {
99925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99926       };
99927     }
99928   }
99929
99930   jresult = (void *)result;
99931   return jresult;
99932 }
99933
99934
99935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99937
99938   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99939   {
99940     try {
99941       (arg1)->Reset();
99942     } catch (std::out_of_range& e) {
99943       {
99944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99945       };
99946     } catch (std::exception& e) {
99947       {
99948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99949       };
99950     } catch (Dali::DaliException e) {
99951       {
99952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99953       };
99954     } catch (...) {
99955       {
99956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99957       };
99958     }
99959   }
99960
99961 }
99962
99963
99964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99965   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99966   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99967
99968   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99969   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99970   {
99971     try {
99972       (arg1)->Reset(arg2);
99973     } catch (std::out_of_range& e) {
99974       {
99975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99976       };
99977     } catch (std::exception& e) {
99978       {
99979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99980       };
99981     } catch (Dali::DaliException e) {
99982       {
99983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99984       };
99985     } catch (...) {
99986       {
99987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99988       };
99989     }
99990   }
99991
99992 }
99993
99994
99995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99996   void * jresult ;
99997   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99998   Dali::Toolkit::Ruler *result = 0 ;
99999
100000   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100001   {
100002     try {
100003       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100004     } catch (std::out_of_range& e) {
100005       {
100006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100007       };
100008     } catch (std::exception& e) {
100009       {
100010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100011       };
100012     } catch (Dali::DaliException e) {
100013       {
100014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100015       };
100016     } catch (...) {
100017       {
100018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100019       };
100020     }
100021   }
100022
100023   jresult = (void *)result;
100024   return jresult;
100025 }
100026
100027
100028 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100029   float jresult ;
100030   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100031   float arg2 ;
100032   float arg3 ;
100033   float result;
100034
100035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100036   arg2 = (float)jarg2;
100037   arg3 = (float)jarg3;
100038   {
100039     try {
100040       result = (float)(*arg1)->Snap(arg2,arg3);
100041     } catch (std::out_of_range& e) {
100042       {
100043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100044       };
100045     } catch (std::exception& e) {
100046       {
100047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100048       };
100049     } catch (Dali::DaliException e) {
100050       {
100051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100052       };
100053     } catch (...) {
100054       {
100055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100056       };
100057     }
100058   }
100059
100060   jresult = result;
100061   return jresult;
100062 }
100063
100064
100065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100066   float jresult ;
100067   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100068   float arg2 ;
100069   float result;
100070
100071   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100072   arg2 = (float)jarg2;
100073   {
100074     try {
100075       result = (float)(*arg1)->Snap(arg2);
100076     } catch (std::out_of_range& e) {
100077       {
100078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100079       };
100080     } catch (std::exception& e) {
100081       {
100082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100083       };
100084     } catch (Dali::DaliException e) {
100085       {
100086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100087       };
100088     } catch (...) {
100089       {
100090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100091       };
100092     }
100093   }
100094
100095   jresult = result;
100096   return jresult;
100097 }
100098
100099
100100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100101   float jresult ;
100102   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100103   unsigned int arg2 ;
100104   unsigned int *arg3 = 0 ;
100105   bool arg4 ;
100106   float result;
100107
100108   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100109   arg2 = (unsigned int)jarg2;
100110   arg3 = (unsigned int *)jarg3;
100111   arg4 = jarg4 ? true : false;
100112   {
100113     try {
100114       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100115     } catch (std::out_of_range& e) {
100116       {
100117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100118       };
100119     } catch (std::exception& e) {
100120       {
100121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100122       };
100123     } catch (Dali::DaliException e) {
100124       {
100125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100126       };
100127     } catch (...) {
100128       {
100129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100130       };
100131     }
100132   }
100133
100134   jresult = result;
100135   return jresult;
100136 }
100137
100138
100139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100140   unsigned int jresult ;
100141   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100142   float arg2 ;
100143   bool arg3 ;
100144   unsigned int result;
100145
100146   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100147   arg2 = (float)jarg2;
100148   arg3 = jarg3 ? true : false;
100149   {
100150     try {
100151       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100152     } catch (std::out_of_range& e) {
100153       {
100154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100155       };
100156     } catch (std::exception& e) {
100157       {
100158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100159       };
100160     } catch (Dali::DaliException e) {
100161       {
100162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100163       };
100164     } catch (...) {
100165       {
100166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100167       };
100168     }
100169   }
100170
100171   jresult = result;
100172   return jresult;
100173 }
100174
100175
100176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100177   unsigned int jresult ;
100178   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100179   unsigned int result;
100180
100181   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100182   {
100183     try {
100184       result = (unsigned int)(*arg1)->GetTotalPages();
100185     } catch (std::out_of_range& e) {
100186       {
100187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100188       };
100189     } catch (std::exception& e) {
100190       {
100191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100192       };
100193     } catch (Dali::DaliException e) {
100194       {
100195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100196       };
100197     } catch (...) {
100198       {
100199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100200       };
100201     }
100202   }
100203
100204   jresult = result;
100205   return jresult;
100206 }
100207
100208
100209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100210   int jresult ;
100211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100212   Dali::Toolkit::Ruler::RulerType result;
100213
100214   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100215   {
100216     try {
100217       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100218     } catch (std::out_of_range& e) {
100219       {
100220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100221       };
100222     } catch (std::exception& e) {
100223       {
100224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100225       };
100226     } catch (Dali::DaliException e) {
100227       {
100228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100229       };
100230     } catch (...) {
100231       {
100232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100233       };
100234     }
100235   }
100236
100237   jresult = (int)result;
100238   return jresult;
100239 }
100240
100241
100242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100243   unsigned int jresult ;
100244   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100245   bool result;
100246
100247   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100248   {
100249     try {
100250       result = (bool)(*arg1)->IsEnabled();
100251     } catch (std::out_of_range& e) {
100252       {
100253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100254       };
100255     } catch (std::exception& e) {
100256       {
100257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100258       };
100259     } catch (Dali::DaliException e) {
100260       {
100261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100262       };
100263     } catch (...) {
100264       {
100265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100266       };
100267     }
100268   }
100269
100270   jresult = result;
100271   return jresult;
100272 }
100273
100274
100275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100276   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100277
100278   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100279   {
100280     try {
100281       (*arg1)->Enable();
100282     } catch (std::out_of_range& e) {
100283       {
100284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100285       };
100286     } catch (std::exception& e) {
100287       {
100288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100289       };
100290     } catch (Dali::DaliException e) {
100291       {
100292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100293       };
100294     } catch (...) {
100295       {
100296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100297       };
100298     }
100299   }
100300
100301 }
100302
100303
100304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100305   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100306
100307   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100308   {
100309     try {
100310       (*arg1)->Disable();
100311     } catch (std::out_of_range& e) {
100312       {
100313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100314       };
100315     } catch (std::exception& e) {
100316       {
100317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100318       };
100319     } catch (Dali::DaliException e) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100322       };
100323     } catch (...) {
100324       {
100325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100326       };
100327     }
100328   }
100329
100330 }
100331
100332
100333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100334   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100335   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100336   Dali::Toolkit::RulerDomain *argp2 ;
100337
100338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100339   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100340   if (!argp2) {
100341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100342     return ;
100343   }
100344   arg2 = *argp2;
100345   {
100346     try {
100347       (*arg1)->SetDomain(arg2);
100348     } catch (std::out_of_range& e) {
100349       {
100350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100351       };
100352     } catch (std::exception& e) {
100353       {
100354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100355       };
100356     } catch (Dali::DaliException e) {
100357       {
100358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100359       };
100360     } catch (...) {
100361       {
100362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100363       };
100364     }
100365   }
100366
100367 }
100368
100369
100370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100371   void * jresult ;
100372   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100373   Dali::Toolkit::RulerDomain *result = 0 ;
100374
100375   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100376   {
100377     try {
100378       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100379     } catch (std::out_of_range& e) {
100380       {
100381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100382       };
100383     } catch (std::exception& e) {
100384       {
100385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100386       };
100387     } catch (Dali::DaliException e) {
100388       {
100389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100390       };
100391     } catch (...) {
100392       {
100393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100394       };
100395     }
100396   }
100397
100398   jresult = (void *)result;
100399   return jresult;
100400 }
100401
100402
100403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100404   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100405
100406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100407   {
100408     try {
100409       (*arg1)->DisableDomain();
100410     } catch (std::out_of_range& e) {
100411       {
100412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100413       };
100414     } catch (std::exception& e) {
100415       {
100416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100417       };
100418     } catch (Dali::DaliException e) {
100419       {
100420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100421       };
100422     } catch (...) {
100423       {
100424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100425       };
100426     }
100427   }
100428
100429 }
100430
100431
100432 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100433   float jresult ;
100434   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100435   float arg2 ;
100436   float arg3 ;
100437   float arg4 ;
100438   float result;
100439
100440   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100441   arg2 = (float)jarg2;
100442   arg3 = (float)jarg3;
100443   arg4 = (float)jarg4;
100444   {
100445     try {
100446       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100447     } catch (std::out_of_range& e) {
100448       {
100449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100450       };
100451     } catch (std::exception& e) {
100452       {
100453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100454       };
100455     } catch (Dali::DaliException e) {
100456       {
100457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100458       };
100459     } catch (...) {
100460       {
100461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100462       };
100463     }
100464   }
100465
100466   jresult = result;
100467   return jresult;
100468 }
100469
100470
100471 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100472   float jresult ;
100473   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100474   float arg2 ;
100475   float arg3 ;
100476   float result;
100477
100478   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100479   arg2 = (float)jarg2;
100480   arg3 = (float)jarg3;
100481   {
100482     try {
100483       result = (float)(*arg1)->Clamp(arg2,arg3);
100484     } catch (std::out_of_range& e) {
100485       {
100486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100487       };
100488     } catch (std::exception& e) {
100489       {
100490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100491       };
100492     } catch (Dali::DaliException e) {
100493       {
100494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100495       };
100496     } catch (...) {
100497       {
100498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100499       };
100500     }
100501   }
100502
100503   jresult = result;
100504   return jresult;
100505 }
100506
100507
100508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100509   float jresult ;
100510   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100511   float arg2 ;
100512   float result;
100513
100514   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100515   arg2 = (float)jarg2;
100516   {
100517     try {
100518       result = (float)(*arg1)->Clamp(arg2);
100519     } catch (std::out_of_range& e) {
100520       {
100521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100522       };
100523     } catch (std::exception& e) {
100524       {
100525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100526       };
100527     } catch (Dali::DaliException e) {
100528       {
100529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100530       };
100531     } catch (...) {
100532       {
100533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100534       };
100535     }
100536   }
100537
100538   jresult = result;
100539   return jresult;
100540 }
100541
100542
100543 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100544   float jresult ;
100545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100546   float arg2 ;
100547   float arg3 ;
100548   float arg4 ;
100549   Dali::Toolkit::ClampState *arg5 = 0 ;
100550   float result;
100551
100552   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100553   arg2 = (float)jarg2;
100554   arg3 = (float)jarg3;
100555   arg4 = (float)jarg4;
100556   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100557   if (!arg5) {
100558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100559     return 0;
100560   }
100561   {
100562     try {
100563       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100564     } catch (std::out_of_range& e) {
100565       {
100566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100567       };
100568     } catch (std::exception& e) {
100569       {
100570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100571       };
100572     } catch (Dali::DaliException e) {
100573       {
100574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100575       };
100576     } catch (...) {
100577       {
100578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100579       };
100580     }
100581   }
100582
100583   jresult = result;
100584   return jresult;
100585 }
100586
100587
100588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100589   float jresult ;
100590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100591   float arg2 ;
100592   float arg3 ;
100593   float arg4 ;
100594   float arg5 ;
100595   float result;
100596
100597   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100598   arg2 = (float)jarg2;
100599   arg3 = (float)jarg3;
100600   arg4 = (float)jarg4;
100601   arg5 = (float)jarg5;
100602   {
100603     try {
100604       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100605     } catch (std::out_of_range& e) {
100606       {
100607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100608       };
100609     } catch (std::exception& e) {
100610       {
100611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100612       };
100613     } catch (Dali::DaliException e) {
100614       {
100615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100616       };
100617     } catch (...) {
100618       {
100619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100620       };
100621     }
100622   }
100623
100624   jresult = result;
100625   return jresult;
100626 }
100627
100628
100629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100630   float jresult ;
100631   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100632   float arg2 ;
100633   float arg3 ;
100634   float arg4 ;
100635   float result;
100636
100637   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100638   arg2 = (float)jarg2;
100639   arg3 = (float)jarg3;
100640   arg4 = (float)jarg4;
100641   {
100642     try {
100643       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100644     } catch (std::out_of_range& e) {
100645       {
100646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100647       };
100648     } catch (std::exception& e) {
100649       {
100650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100651       };
100652     } catch (Dali::DaliException e) {
100653       {
100654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100655       };
100656     } catch (...) {
100657       {
100658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100659       };
100660     }
100661   }
100662
100663   jresult = result;
100664   return jresult;
100665 }
100666
100667
100668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100669   float jresult ;
100670   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100671   float arg2 ;
100672   float arg3 ;
100673   float result;
100674
100675   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100676   arg2 = (float)jarg2;
100677   arg3 = (float)jarg3;
100678   {
100679     try {
100680       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100681     } catch (std::out_of_range& e) {
100682       {
100683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100684       };
100685     } catch (std::exception& e) {
100686       {
100687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100688       };
100689     } catch (Dali::DaliException e) {
100690       {
100691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100692       };
100693     } catch (...) {
100694       {
100695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100696       };
100697     }
100698   }
100699
100700   jresult = result;
100701   return jresult;
100702 }
100703
100704
100705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100706   float jresult ;
100707   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100708   float arg2 ;
100709   float result;
100710
100711   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100712   arg2 = (float)jarg2;
100713   {
100714     try {
100715       result = (float)(*arg1)->SnapAndClamp(arg2);
100716     } catch (std::out_of_range& e) {
100717       {
100718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100719       };
100720     } catch (std::exception& e) {
100721       {
100722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100723       };
100724     } catch (Dali::DaliException e) {
100725       {
100726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100727       };
100728     } catch (...) {
100729       {
100730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100731       };
100732     }
100733   }
100734
100735   jresult = result;
100736   return jresult;
100737 }
100738
100739
100740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100741   float jresult ;
100742   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100743   float arg2 ;
100744   float arg3 ;
100745   float arg4 ;
100746   float arg5 ;
100747   Dali::Toolkit::ClampState *arg6 = 0 ;
100748   float result;
100749
100750   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100751   arg2 = (float)jarg2;
100752   arg3 = (float)jarg3;
100753   arg4 = (float)jarg4;
100754   arg5 = (float)jarg5;
100755   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100756   if (!arg6) {
100757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100758     return 0;
100759   }
100760   {
100761     try {
100762       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100763     } catch (std::out_of_range& e) {
100764       {
100765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100766       };
100767     } catch (std::exception& e) {
100768       {
100769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100770       };
100771     } catch (Dali::DaliException e) {
100772       {
100773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100774       };
100775     } catch (...) {
100776       {
100777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100778       };
100779     }
100780   }
100781
100782   jresult = result;
100783   return jresult;
100784 }
100785
100786
100787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100789
100790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100791   {
100792     try {
100793       (*arg1)->Reference();
100794     } catch (std::out_of_range& e) {
100795       {
100796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100797       };
100798     } catch (std::exception& e) {
100799       {
100800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100801       };
100802     } catch (Dali::DaliException e) {
100803       {
100804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100805       };
100806     } catch (...) {
100807       {
100808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100809       };
100810     }
100811   }
100812
100813 }
100814
100815
100816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100818
100819   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100820   {
100821     try {
100822       (*arg1)->Unreference();
100823     } catch (std::out_of_range& e) {
100824       {
100825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100826       };
100827     } catch (std::exception& e) {
100828       {
100829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100830       };
100831     } catch (Dali::DaliException e) {
100832       {
100833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100834       };
100835     } catch (...) {
100836       {
100837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100838       };
100839     }
100840   }
100841
100842 }
100843
100844
100845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100846   int jresult ;
100847   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100848   int result;
100849
100850   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100851   {
100852     try {
100853       result = (int)(*arg1)->ReferenceCount();
100854     } catch (std::out_of_range& e) {
100855       {
100856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100857       };
100858     } catch (std::exception& e) {
100859       {
100860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100861       };
100862     } catch (Dali::DaliException e) {
100863       {
100864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100865       };
100866     } catch (...) {
100867       {
100868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100869       };
100870     }
100871   }
100872
100873   jresult = result;
100874   return jresult;
100875 }
100876
100877
100878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100879   unsigned int jresult ;
100880   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100881   bool result;
100882
100883   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100884   {
100885     try {
100886       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100887     } catch (std::out_of_range& e) {
100888       {
100889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100890       };
100891     } catch (std::exception& e) {
100892       {
100893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100894       };
100895     } catch (Dali::DaliException e) {
100896       {
100897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100898       };
100899     } catch (...) {
100900       {
100901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100902       };
100903     }
100904   }
100905
100906   jresult = result;
100907   return jresult;
100908 }
100909
100910
100911 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100912   unsigned long jresult ;
100913   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100914   std::size_t result;
100915
100916   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100917   {
100918     try {
100919       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100920     } catch (std::out_of_range& e) {
100921       {
100922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100923       };
100924     } catch (std::exception& e) {
100925       {
100926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100927       };
100928     } catch (Dali::DaliException e) {
100929       {
100930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100931       };
100932     } catch (...) {
100933       {
100934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100935       };
100936     }
100937   }
100938
100939   jresult = (unsigned long)result;
100940   return jresult;
100941 }
100942
100943
100944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100945   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100946   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100947
100948   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100949   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100950   {
100951     try {
100952       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100953     } catch (std::out_of_range& e) {
100954       {
100955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100956       };
100957     } catch (std::exception& e) {
100958       {
100959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100960       };
100961     } catch (Dali::DaliException e) {
100962       {
100963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100964       };
100965     } catch (...) {
100966       {
100967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100968       };
100969     }
100970   }
100971
100972 }
100973
100974
100975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100976   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100977   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100978
100979   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100980   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100981   {
100982     try {
100983       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100984     } catch (std::out_of_range& e) {
100985       {
100986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100987       };
100988     } catch (std::exception& e) {
100989       {
100990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100991       };
100992     } catch (Dali::DaliException e) {
100993       {
100994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100995       };
100996     } catch (...) {
100997       {
100998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100999       };
101000     }
101001   }
101002
101003 }
101004
101005
101006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101007   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101008   Dali::Toolkit::Control arg2 ;
101009   Dali::Toolkit::Control *argp2 ;
101010
101011   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101012   argp2 = (Dali::Toolkit::Control *)jarg2;
101013   if (!argp2) {
101014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101015     return ;
101016   }
101017   arg2 = *argp2;
101018   {
101019     try {
101020       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101021     } catch (std::out_of_range& e) {
101022       {
101023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101024       };
101025     } catch (std::exception& e) {
101026       {
101027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101028       };
101029     } catch (Dali::DaliException e) {
101030       {
101031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101032       };
101033     } catch (...) {
101034       {
101035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101036       };
101037     }
101038   }
101039
101040 }
101041
101042
101043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101044   void * jresult ;
101045   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101046
101047   {
101048     try {
101049       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101050     } catch (std::out_of_range& e) {
101051       {
101052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101053       };
101054     } catch (std::exception& e) {
101055       {
101056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101057       };
101058     } catch (Dali::DaliException e) {
101059       {
101060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101061       };
101062     } catch (...) {
101063       {
101064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101065       };
101066     }
101067   }
101068
101069   jresult = (void *)result;
101070   return jresult;
101071 }
101072
101073
101074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101075   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101076
101077   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101078   {
101079     try {
101080       delete arg1;
101081     } catch (std::out_of_range& e) {
101082       {
101083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101084       };
101085     } catch (std::exception& e) {
101086       {
101087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101088       };
101089     } catch (Dali::DaliException e) {
101090       {
101091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101092       };
101093     } catch (...) {
101094       {
101095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101096       };
101097     }
101098   }
101099
101100 }
101101
101102 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101103   Dali::RefObject *result = NULL;
101104
101105   if (arg1)
101106   {
101107     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101108   }
101109   return result;
101110 }
101111
101112 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101113     return (Dali::RefObject *)jarg1;
101114 }
101115
101116 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101117     return (Dali::SignalObserver *)jarg1;
101118 }
101119
101120 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101121     return (Dali::ConnectionTrackerInterface *)jarg1;
101122 }
101123
101124 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101125     return (Dali::BaseHandle *)jarg1;
101126 }
101127
101128 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101129     return (Dali::BaseHandle *)jarg1;
101130 }
101131
101132 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101133     return (Dali::BaseHandle *)jarg1;
101134 }
101135
101136 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101137     return (Dali::BaseHandle *)jarg1;
101138 }
101139
101140 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101141     return (Dali::BaseHandle *)jarg1;
101142 }
101143
101144 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101145     return (Dali::BaseHandle *)jarg1;
101146 }
101147
101148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101149     return (Dali::BaseHandle *)jarg1;
101150 }
101151
101152 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101153     return (Dali::BaseHandle *)jarg1;
101154 }
101155
101156 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101157     return (Dali::BaseHandle *)jarg1;
101158 }
101159
101160 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101161     return (Dali::BaseHandle *)jarg1;
101162 }
101163
101164 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101165     return (Dali::BaseHandle *)jarg1;
101166 }
101167
101168 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101169     return (Dali::BaseHandle *)jarg1;
101170 }
101171
101172 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101173     return (Dali::BaseHandle *)jarg1;
101174 }
101175
101176 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101177     return (Dali::Handle *)jarg1;
101178 }
101179
101180 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101181     return (Dali::Handle *)jarg1;
101182 }
101183
101184 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101185     return (Dali::BaseHandle *)jarg1;
101186 }
101187
101188 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101189     return (Dali::BaseHandle *)jarg1;
101190 }
101191
101192 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101193     return (Dali::Handle *)jarg1;
101194 }
101195
101196 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101197     return (Dali::BaseHandle *)jarg1;
101198 }
101199
101200 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101201     return (Dali::Handle *)jarg1;
101202 }
101203
101204 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101205     return (Dali::GestureDetector *)jarg1;
101206 }
101207
101208 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101209     return (Dali::Gesture *)jarg1;
101210 }
101211
101212 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101213     return (Dali::Handle *)jarg1;
101214 }
101215
101216 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101217     return (Dali::Actor *)jarg1;
101218 }
101219
101220 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101221     return (Dali::BaseHandle *)jarg1;
101222 }
101223
101224 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101225     return (Dali::RefObject *)jarg1;
101226 }
101227
101228 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101229     return (Dali::Actor *)jarg1;
101230 }
101231
101232 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101233     return (Dali::GestureDetector *)jarg1;
101234 }
101235
101236 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101237     return (Dali::Gesture *)jarg1;
101238 }
101239
101240 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101241     return (Dali::GestureDetector *)jarg1;
101242 }
101243
101244 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101245     return (Dali::Gesture *)jarg1;
101246 }
101247
101248 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101249     return (Dali::GestureDetector *)jarg1;
101250 }
101251
101252 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101253     return (Dali::Gesture *)jarg1;
101254 }
101255
101256 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101257     return (Dali::BaseHandle *)jarg1;
101258 }
101259
101260 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101261     return (Dali::Handle *)jarg1;
101262 }
101263
101264 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101265     return (Dali::Handle *)jarg1;
101266 }
101267
101268 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101269     return (Dali::Handle *)jarg1;
101270 }
101271
101272 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101273     return (Dali::Image *)jarg1;
101274 }
101275
101276 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101277     return (Dali::Image *)jarg1;
101278 }
101279
101280 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101281     return (Dali::Image *)jarg1;
101282 }
101283
101284 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101285     return (Dali::RefObject *)jarg1;
101286 }
101287
101288 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101289     return (Dali::Image *)jarg1;
101290 }
101291
101292 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101293     return (Dali::Image *)jarg1;
101294 }
101295
101296 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101297     return (Dali::ResourceImage *)jarg1;
101298 }
101299
101300 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101301     return (Dali::Actor *)jarg1;
101302 }
101303
101304 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101305     return (Dali::BaseHandle *)jarg1;
101306 }
101307
101308 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101309     return (Dali::BaseHandle *)jarg1;
101310 }
101311
101312
101313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101314     return (Dali::BaseHandle *)jarg1;
101315 }
101316
101317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101318     return (Dali::BaseHandle *)jarg1;
101319 }
101320
101321 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101322     return (Dali::CustomActorImpl *)jarg1;
101323 }
101324
101325 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101326     return (Dali::CustomActor *)jarg1;
101327 }
101328
101329 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101330     return (Dali::BaseHandle *)jarg1;
101331 }
101332
101333 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101334     return (Dali::Toolkit::Control *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101338     return (Dali::Toolkit::Control *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101342     return (Dali::Toolkit::Button *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101346     return (Dali::Toolkit::Button *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101350     return (Dali::Toolkit::Button *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101354     return (Dali::Toolkit::Control *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101358     return (Dali::Toolkit::Control *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101362     return (Dali::Toolkit::Control *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101366     return (Dali::Toolkit::Control *)jarg1;
101367 }
101368
101369 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101370     return (Dali::Toolkit::Control *)jarg1;
101371 }
101372
101373 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101374     return (Dali::RefObject *)jarg1;
101375 }
101376
101377 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101378     return (Dali::Toolkit::Scrollable *)jarg1;
101379 }
101380
101381 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101382     return (Dali::BaseHandle *)jarg1;
101383 }
101384
101385 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101386     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101387 }
101388
101389 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101390     return (Dali::RefObject *)jarg1;
101391 }
101392
101393 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101394     return (Dali::Toolkit::Ruler *)jarg1;
101395 }
101396
101397 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101398     return (Dali::Toolkit::Ruler *)jarg1;
101399 }
101400
101401 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101402     return (Dali::Toolkit::Scrollable *)jarg1;
101403 }
101404
101405 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101406     return (Dali::Toolkit::Control *)jarg1;
101407 }
101408
101409
101410 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101411     return (Dali::Toolkit::Control *)jarg1;
101412 }
101413
101414 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101415     return (Dali::BaseHandle *)jarg1;
101416 }
101417
101418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101419     return (Dali::BaseHandle *)jarg1;
101420 }
101421
101422 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101423     return (Dali::Toolkit::Control *)jarg1;
101424 }
101425
101426 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101427     return (Dali::Toolkit::Control *)jarg1;
101428 }
101429
101430 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101431     return (Dali::Toolkit::Control *)jarg1;
101432 }
101433
101434 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101435     return (Dali::Toolkit::Control *)jarg1;
101436 }
101437
101438 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101439     return (Dali::Toolkit::Control *)jarg1;
101440 }
101441
101442 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101443     return (Dali::Toolkit::Control *)jarg1;
101444 }
101445
101446 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101447     return (Dali::Toolkit::PageTurnView *)jarg1;
101448 }
101449
101450 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101451     return (Dali::Toolkit::PageTurnView *)jarg1;
101452 }
101453
101454 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101455     return (Dali::Toolkit::Button *)jarg1;
101456 }
101457
101458 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101459     return (Dali::BaseHandle *)jarg1;
101460 }
101461
101462 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101463     return (Dali::BaseHandle *)jarg1;
101464 }
101465
101466 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101467     return (Dali::BaseHandle *)jarg1;
101468 }
101469
101470 /*
101471  * Widget binding
101472  */
101473 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101474     return (Dali::BaseHandle *)jarg1;
101475 }
101476
101477 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101478     return (Dali::BaseObject *)jarg1;
101479 }
101480
101481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101482   void * jresult ;
101483   Dali::Widget result;
101484
101485   {
101486     try {
101487       result = Dali::Widget::New();
101488     } catch (std::out_of_range& e) {
101489       {
101490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101491       };
101492     } catch (std::exception& e) {
101493       {
101494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101495       };
101496     } catch (...) {
101497       {
101498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101499       };
101500     }
101501   }
101502   jresult = new Dali::Widget((const Dali::Widget &)result);
101503   return jresult;
101504 }
101505
101506
101507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101508   void * jresult ;
101509   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101510   Dali::Widget result;
101511
101512   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101513
101514   if (!arg1) {
101515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101516     return 0;
101517   }
101518   {
101519     try {
101520       jresult = new Dali::Widget(arg1);
101521     } catch (std::out_of_range& e) {
101522       {
101523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101524       };
101525     } catch (std::exception& e) {
101526       {
101527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101528       };
101529     } catch (...) {
101530       {
101531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101532       };
101533     }
101534   }
101535   return jresult;
101536 }
101537
101538
101539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101540   void * jresult ;
101541   Dali::Widget *result = 0 ;
101542
101543   {
101544     try {
101545       result = (Dali::Widget *)new Dali::Widget();
101546     } catch (std::out_of_range& e) {
101547       {
101548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101549       };
101550     } catch (std::exception& e) {
101551       {
101552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101553       };
101554     } catch (...) {
101555       {
101556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101557       };
101558     }
101559   }
101560   jresult = (void *)result;
101561   return jresult;
101562 }
101563
101564
101565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101566   void * jresult ;
101567   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101568   Dali::Widget *arg2 = 0 ;
101569   Dali::Widget *result = 0 ;
101570
101571   arg1 = (Dali::Widget *)jarg1;
101572   arg2 = (Dali::Widget *)jarg2;
101573   if (!arg2) {
101574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101575     return 0;
101576   }
101577   {
101578     try {
101579       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101580     } catch (std::out_of_range& e) {
101581       {
101582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101583       };
101584     } catch (std::exception& e) {
101585       {
101586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101587       };
101588     } catch (...) {
101589       {
101590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101591       };
101592     }
101593   }
101594   jresult = (void *)result;
101595   return jresult;
101596 }
101597
101598
101599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101600   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101601
101602   arg1 = (Dali::Widget *)jarg1;
101603   {
101604     try {
101605       delete arg1;
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
101623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101624   void * jresult ;
101625   SwigDirector_WidgetImpl* result;
101626   {
101627     try {
101628       result = new SwigDirector_WidgetImpl();
101629     } catch (std::out_of_range& e) {
101630       {
101631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101632       };
101633     } catch (std::exception& e) {
101634       {
101635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101636       };
101637     } catch (...) {
101638       {
101639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101640       };
101641     }
101642   }
101643   jresult = result;
101644   return jresult;
101645 }
101646
101647
101648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101649   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101650   std::string *arg2 = 0 ;
101651   Dali::Window arg3 ;
101652   Dali::Window *argp3 ;
101653
101654   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101655   if (!jarg2) {
101656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101657     return ;
101658   }
101659   std::string arg2_str(jarg2);
101660   arg2 = &arg2_str;
101661   argp3 = (Dali::Window *)jarg3;
101662   if (!argp3) {
101663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101664     return ;
101665   }
101666   arg3 = *argp3;
101667   {
101668     try {
101669       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101670     } catch (std::out_of_range& e) {
101671       {
101672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101673       };
101674     } catch (std::exception& e) {
101675       {
101676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101677       };
101678     } catch (...) {
101679       {
101680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101681       };
101682     }
101683   }
101684 }
101685
101686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101687   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101688   std::string *arg2 = 0 ;
101689   Dali::Window arg3 ;
101690   Dali::Window *argp3 ;
101691
101692   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101693   if (!jarg2) {
101694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101695     return ;
101696   }
101697   std::string arg2_str(jarg2);
101698   arg2 = &arg2_str;
101699   argp3 = (Dali::Window *)jarg3;
101700   if (!argp3) {
101701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101702     return ;
101703   }
101704   arg3 = *argp3;
101705   {
101706     try {
101707       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
101708     } catch (std::out_of_range& e) {
101709       {
101710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101711       };
101712     } catch (std::exception& e) {
101713       {
101714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101715       };
101716     } catch (...) {
101717       {
101718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101719       };
101720     }
101721   }
101722 }
101723
101724
101725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101726   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101727   std::string *arg2 = 0 ;
101728   Dali::Widget::Termination arg3 ;
101729
101730   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101731   if (!jarg2) {
101732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101733     return ;
101734   }
101735   std::string arg2_str(jarg2);
101736   arg2 = &arg2_str;
101737   arg3 = (Dali::Widget::Termination)jarg3;
101738   {
101739     try {
101740       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101741     } catch (std::out_of_range& e) {
101742       {
101743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101744       };
101745     } catch (std::exception& e) {
101746       {
101747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101748       };
101749     } catch (...) {
101750       {
101751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101752       };
101753     }
101754   }
101755 }
101756
101757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101758   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101759   std::string *arg2 = 0 ;
101760   Dali::Widget::Termination arg3 ;
101761
101762   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101763   if (!jarg2) {
101764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101765     return ;
101766   }
101767   std::string arg2_str(jarg2);
101768   arg2 = &arg2_str;
101769   arg3 = (Dali::Widget::Termination)jarg3;
101770   {
101771     try {
101772       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101773     } catch (std::out_of_range& e) {
101774       {
101775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101776       };
101777     } catch (std::exception& e) {
101778       {
101779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101780       };
101781     } catch (...) {
101782       {
101783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101784       };
101785     }
101786   }
101787 }
101788
101789
101790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101791   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101792
101793   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101794   {
101795     try {
101796       (arg1)->OnPause();
101797     } catch (std::out_of_range& e) {
101798       {
101799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101800       };
101801     } catch (std::exception& e) {
101802       {
101803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101804       };
101805     } catch (...) {
101806       {
101807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101808       };
101809     }
101810   }
101811 }
101812
101813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101814   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101815
101816   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101817   {
101818     try {
101819       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101820     } catch (std::out_of_range& e) {
101821       {
101822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101823       };
101824     } catch (std::exception& e) {
101825       {
101826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101827       };
101828     } catch (...) {
101829       {
101830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101831       };
101832     }
101833   }
101834 }
101835
101836
101837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101838   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101839
101840   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101841   {
101842     try {
101843       (arg1)->OnResume();
101844     } catch (std::out_of_range& e) {
101845       {
101846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101847       };
101848     } catch (std::exception& e) {
101849       {
101850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101851       };
101852     } catch (...) {
101853       {
101854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101855       };
101856     }
101857   }
101858 }
101859
101860
101861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101862   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101863
101864   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101865   {
101866     try {
101867       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101868     } catch (std::out_of_range& e) {
101869       {
101870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101871       };
101872     } catch (std::exception& e) {
101873       {
101874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101875       };
101876     } catch (...) {
101877       {
101878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101879       };
101880     }
101881   }
101882 }
101883
101884
101885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101886   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101887   Dali::Window arg2 ;
101888   Dali::Window *argp2 ;
101889
101890   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101891   argp2 = (Dali::Window *)jarg2;
101892   if (!argp2) {
101893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101894     return ;
101895   }
101896   arg2 = *argp2;
101897   {
101898     try {
101899       (arg1)->OnResize(arg2);
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_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101918   Dali::Window arg2 ;
101919   Dali::Window *argp2 ;
101920
101921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101922   argp2 = (Dali::Window *)jarg2;
101923   if (!argp2) {
101924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101925     return ;
101926   }
101927   arg2 = *argp2;
101928   {
101929     try {
101930       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101931     } catch (std::out_of_range& e) {
101932       {
101933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101934       };
101935     } catch (std::exception& e) {
101936       {
101937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101938       };
101939     } catch (...) {
101940       {
101941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101942       };
101943     }
101944   }
101945 }
101946
101947
101948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101949   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101950   std::string *arg2 = 0 ;
101951   int arg3 ;
101952
101953   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101954   if (!jarg2) {
101955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101956     return ;
101957   }
101958   std::string arg2_str(jarg2);
101959   arg2 = &arg2_str;
101960   arg3 = (int)jarg3;
101961   {
101962     try {
101963       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101964     } catch (std::out_of_range& e) {
101965       {
101966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101967       };
101968     } catch (std::exception& e) {
101969       {
101970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101971       };
101972     } catch (...) {
101973       {
101974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101975       };
101976     }
101977   }
101978 }
101979
101980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101981   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101982   std::string *arg2 = 0 ;
101983   int arg3 ;
101984
101985   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101986   if (!jarg2) {
101987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101988     return ;
101989   }
101990   std::string arg2_str(jarg2);
101991   arg2 = &arg2_str;
101992   arg3 = (int)jarg3;
101993   {
101994     try {
101995       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101996     } catch (std::out_of_range& e) {
101997       {
101998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101999       };
102000     } catch (std::exception& e) {
102001       {
102002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102003       };
102004     } catch (...) {
102005       {
102006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102007       };
102008     }
102009   }
102010 }
102011
102012
102013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102014   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102015   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102016   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102017
102018   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102019   arg2 = (Dali::SlotObserver *)jarg2;
102020   arg3 = (Dali::CallbackBase *)jarg3;
102021   {
102022     try {
102023       (arg1)->SignalConnected(arg2,arg3);
102024     } catch (std::out_of_range& e) {
102025       {
102026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102027       };
102028     } catch (std::exception& e) {
102029       {
102030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102031       };
102032     } catch (...) {
102033       {
102034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102035       };
102036     }
102037   }
102038 }
102039
102040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102041   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102042   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102043   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102044
102045   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102046   arg2 = (Dali::SlotObserver *)jarg2;
102047   arg3 = (Dali::CallbackBase *)jarg3;
102048   {
102049     try {
102050       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102051     } catch (std::out_of_range& e) {
102052       {
102053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102054       };
102055     } catch (std::exception& e) {
102056       {
102057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102058       };
102059     } catch (...) {
102060       {
102061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102062       };
102063     }
102064   }
102065 }
102066
102067
102068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102069   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102070   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102071   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102072
102073   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102074   arg2 = (Dali::SlotObserver *)jarg2;
102075   arg3 = (Dali::CallbackBase *)jarg3;
102076   {
102077     try {
102078       (arg1)->SignalDisconnected(arg2,arg3);
102079     } catch (std::out_of_range& e) {
102080       {
102081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102082       };
102083     } catch (std::exception& e) {
102084       {
102085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102086       };
102087     } catch (...) {
102088       {
102089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102090       };
102091     }
102092   }
102093 }
102094
102095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102096   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102097   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102098   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102099
102100   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102101   arg2 = (Dali::SlotObserver *)jarg2;
102102   arg3 = (Dali::CallbackBase *)jarg3;
102103   {
102104     try {
102105       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102106     } catch (std::out_of_range& e) {
102107       {
102108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102109       };
102110     } catch (std::exception& e) {
102111       {
102112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102113       };
102114     } catch (...) {
102115       {
102116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102117       };
102118     }
102119   }
102120 }
102121
102122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102123   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102124   std::string *arg2 = 0 ;
102125
102126   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102127   if (!jarg2) {
102128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102129     return ;
102130   }
102131   std::string arg2_str(jarg2);
102132   arg2 = &arg2_str;
102133   {
102134     try {
102135       (arg1)->SetContentInfo((std::string const &)*arg2);
102136     } catch (std::out_of_range& e) {
102137       {
102138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102139       };
102140     } catch (std::exception& e) {
102141       {
102142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102143       };
102144     } catch (...) {
102145       {
102146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102147       };
102148     }
102149   }
102150 }
102151
102152
102153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102154   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102155   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102156
102157   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102158   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102159   {
102160     try {
102161       (arg1)->SetImpl(arg2);
102162     } catch (std::out_of_range& e) {
102163       {
102164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102165       };
102166     } catch (std::exception& e) {
102167       {
102168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102169       };
102170     } catch (...) {
102171       {
102172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102173       };
102174     }
102175   }
102176 }
102177
102178 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) {
102179
102180   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102181   if (director) {
102182     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102183   }
102184 }
102185
102186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102187   void * jresult ;
102188   Dali::Widget *arg1 = 0 ;
102189   SwigDirector_WidgetImpl *result = 0 ;
102190
102191   arg1 = (Dali::Widget *)jarg1;
102192   if (!arg1) {
102193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102194     return 0;
102195   }
102196   {
102197     try {
102198       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102199     } catch (std::out_of_range& e) {
102200       {
102201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102202       };
102203     } catch (std::exception& e) {
102204       {
102205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102206       };
102207     } catch (...) {
102208       {
102209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102210       };
102211     }
102212   }
102213
102214   jresult = (void *)result;
102215   return jresult;
102216 }
102217
102218
102219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102220   void * jresult ;
102221   int *arg1 = (int *) 0 ;
102222   char ***arg2 ;
102223   std::string *arg3 = 0 ;
102224   Dali::WidgetApplication result;
102225   {
102226     int index = 0;
102227     int length = 0;
102228     char *retPtr;
102229     char *nextPtr;
102230     argWidgetC = jarg1;
102231     argWidgetV = new char*[jarg1 + 1];
102232
102233     retPtr = strtok_r( jarg2, " ", &nextPtr);
102234     if( retPtr )
102235     {
102236       length = strlen(retPtr);
102237     }
102238     argWidgetV[index] = new char[length + 1];
102239     if( retPtr )
102240     {
102241       strncpy(argWidgetV[index], retPtr, length);
102242     }
102243     argWidgetV[index][length] = '\0';
102244     index++;
102245
102246     while (index < jarg1)
102247     {
102248       length = 0;
102249       retPtr = strtok_r(NULL, " ", &nextPtr);
102250       if( retPtr )
102251       {
102252         length = strlen(retPtr);
102253       }
102254       argWidgetV[index] = new char[length + 1];
102255       if( retPtr )
102256       {
102257         strncpy(argWidgetV[index], retPtr, length);
102258       }
102259       argWidgetV[index][length] = '\0';
102260       index++;
102261     }
102262
102263     argWidgetV[jarg1] = NULL;
102264     argWidgetC = jarg1;
102265
102266     arg1 = &argWidgetC;
102267     arg2 = &argWidgetV;
102268   }
102269
102270   if (!jarg3) {
102271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102272     return 0;
102273   }
102274   std::string arg3_str(jarg3);
102275   arg3 = &arg3_str;
102276   {
102277     try {
102278       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102279     } catch (std::out_of_range& e) {
102280       {
102281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102282       };
102283     } catch (std::exception& e) {
102284       {
102285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102286       };
102287     } catch (...) {
102288       {
102289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102290       };
102291     }
102292   }
102293   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102294
102295   return jresult;
102296 }
102297
102298
102299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102300   void * jresult ;
102301   Dali::WidgetApplication *result = 0 ;
102302
102303   {
102304     try {
102305       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102306     } catch (std::out_of_range& e) {
102307       {
102308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102309       };
102310     } catch (std::exception& e) {
102311       {
102312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102313       };
102314     } catch (...) {
102315       {
102316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102317       };
102318     }
102319   }
102320   jresult = (void *)result;
102321   return jresult;
102322 }
102323
102324
102325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102326   void * jresult ;
102327   Dali::WidgetApplication *arg1 = 0 ;
102328   Dali::WidgetApplication *result = 0 ;
102329
102330   arg1 = (Dali::WidgetApplication *)jarg1;
102331   if (!arg1) {
102332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102333     return 0;
102334   }
102335   {
102336     try {
102337       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102338     } catch (std::out_of_range& e) {
102339       {
102340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102341       };
102342     } catch (std::exception& e) {
102343       {
102344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102345       };
102346     } catch (...) {
102347       {
102348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102349       };
102350     }
102351   }
102352   jresult = (void *)result;
102353   return jresult;
102354 }
102355
102356
102357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102358   void * jresult ;
102359   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102360   Dali::WidgetApplication *arg2 = 0 ;
102361   Dali::WidgetApplication *result = 0 ;
102362
102363   arg1 = (Dali::WidgetApplication *)jarg1;
102364   arg2 = (Dali::WidgetApplication *)jarg2;
102365   if (!arg2) {
102366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102367     return 0;
102368   }
102369   {
102370     try {
102371       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102372     } catch (std::out_of_range& e) {
102373       {
102374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102375       };
102376     } catch (std::exception& e) {
102377       {
102378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102379       };
102380     } catch (...) {
102381       {
102382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102383       };
102384     }
102385   }
102386   jresult = (void *)result;
102387   return jresult;
102388 }
102389
102390
102391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102392   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102393
102394   arg1 = (Dali::WidgetApplication *)jarg1;
102395   {
102396     try {
102397       delete arg1;
102398       if( argWidgetV )
102399       {
102400         // free string data
102401         for( int i=0; i < argWidgetC+1; i++)
102402         {
102403           delete [] argWidgetV[i];
102404         }
102405         delete [] argWidgetV;
102406       }
102407     } catch (std::out_of_range& e) {
102408       {
102409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102410       };
102411     } catch (std::exception& e) {
102412       {
102413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102414       };
102415     } catch (...) {
102416       {
102417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102418       };
102419     }
102420   }
102421 }
102422
102423
102424 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102425 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102426
102427 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102428 {
102429   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102430   return *widget;
102431 }
102432
102433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102434   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102435   std::string *arg2 = 0 ;
102436
102437   arg1 = (Dali::WidgetApplication *)jarg1;
102438   if (!jarg2) {
102439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102440     return ;
102441   }
102442   std::string arg2_str(*jarg2);
102443   arg2 = &arg2_str;
102444
102445   if(!_CSharpCreateWidgetFunction)
102446   {
102447     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102448   }
102449
102450   {
102451     try {
102452       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102453     } catch (std::out_of_range& e) {
102454       {
102455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102456       };
102457     } catch (std::exception& e) {
102458       {
102459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102460       };
102461     } catch (...) {
102462       {
102463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102464       };
102465     }
102466   }
102467
102468   //Typemap argout in c++ file.
102469   //This will convert c++ string to c# string
102470   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102471 }
102472
102473
102474 //for PixelBuffer and ImageLoading
102475
102476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102477     return (Dali::BaseHandle *)jarg1;
102478 }
102479
102480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102481   void * jresult ;
102482   unsigned int arg1 ;
102483   unsigned int arg2 ;
102484   Dali::Pixel::Format arg3 ;
102485   Dali::Devel::PixelBuffer result;
102486
102487   arg1 = (unsigned int)jarg1;
102488   arg2 = (unsigned int)jarg2;
102489   arg3 = (Dali::Pixel::Format)jarg3;
102490   {
102491     try {
102492       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102493     } catch (std::out_of_range& e) {
102494       {
102495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102496       };
102497     } catch (std::exception& e) {
102498       {
102499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102500       };
102501     } catch (...) {
102502       {
102503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102504       };
102505     }
102506   }
102507   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102508   return jresult;
102509 }
102510
102511
102512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102513   void * jresult ;
102514   Dali::Devel::PixelBuffer *result = 0 ;
102515
102516   {
102517     try {
102518       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102519     } catch (std::out_of_range& e) {
102520       {
102521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102522       };
102523     } catch (std::exception& e) {
102524       {
102525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102526       };
102527     } catch (...) {
102528       {
102529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102530       };
102531     }
102532   }
102533   jresult = (void *)result;
102534   return jresult;
102535 }
102536
102537
102538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102539   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102540
102541   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102542   {
102543     try {
102544       delete arg1;
102545     } catch (std::out_of_range& e) {
102546       {
102547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102548       };
102549     } catch (std::exception& e) {
102550       {
102551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102552       };
102553     } catch (...) {
102554       {
102555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102556       };
102557     }
102558   }
102559 }
102560
102561
102562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102563   void * jresult ;
102564   Dali::Devel::PixelBuffer *arg1 = 0 ;
102565   Dali::Devel::PixelBuffer *result = 0 ;
102566
102567   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102568   if (!arg1) {
102569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102570     return 0;
102571   }
102572   {
102573     try {
102574       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102575     } catch (std::out_of_range& e) {
102576       {
102577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102578       };
102579     } catch (std::exception& e) {
102580       {
102581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102582       };
102583     } catch (...) {
102584       {
102585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102586       };
102587     }
102588   }
102589   jresult = (void *)result;
102590   return jresult;
102591 }
102592
102593
102594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102595   void * jresult ;
102596   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102597   Dali::Devel::PixelBuffer *arg2 = 0 ;
102598   Dali::Devel::PixelBuffer *result = 0 ;
102599
102600   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102601   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102602   if (!arg2) {
102603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102604     return 0;
102605   }
102606   {
102607     try {
102608       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102609     } catch (std::out_of_range& e) {
102610       {
102611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102612       };
102613     } catch (std::exception& e) {
102614       {
102615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102616       };
102617     } catch (...) {
102618       {
102619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102620       };
102621     }
102622   }
102623   jresult = (void *)result;
102624   return jresult;
102625 }
102626
102627
102628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102629   void * jresult ;
102630   Dali::Devel::PixelBuffer *arg1 = 0 ;
102631   Dali::PixelData result;
102632
102633   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102634   if (!arg1) {
102635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102636     return 0;
102637   }
102638   {
102639     try {
102640       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102641     } catch (std::out_of_range& e) {
102642       {
102643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102644       };
102645     } catch (std::exception& e) {
102646       {
102647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102648       };
102649     } catch (...) {
102650       {
102651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102652       };
102653     }
102654   }
102655   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102656   return jresult;
102657 }
102658
102659
102660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102661   void * jresult ;
102662   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102663   Dali::PixelData result;
102664
102665   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102666   {
102667     try {
102668       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102669     } catch (std::out_of_range& e) {
102670       {
102671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102672       };
102673     } catch (std::exception& e) {
102674       {
102675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102676       };
102677     } catch (...) {
102678       {
102679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102680       };
102681     }
102682   }
102683   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102684   return jresult;
102685 }
102686
102687
102688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102689   void * jresult ;
102690   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102691   unsigned char *result = 0 ;
102692
102693   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102694   {
102695     try {
102696       result = (unsigned char *)(arg1)->GetBuffer();
102697     } catch (std::out_of_range& e) {
102698       {
102699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102700       };
102701     } catch (std::exception& e) {
102702       {
102703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102704       };
102705     } catch (...) {
102706       {
102707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102708       };
102709     }
102710   }
102711   jresult = (void *)result;
102712   return jresult;
102713 }
102714
102715
102716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102717   unsigned int jresult ;
102718   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102719   unsigned int result;
102720
102721   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102722   {
102723     try {
102724       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102725     } catch (std::out_of_range& e) {
102726       {
102727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102728       };
102729     } catch (std::exception& e) {
102730       {
102731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102732       };
102733     } catch (...) {
102734       {
102735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102736       };
102737     }
102738   }
102739   jresult = result;
102740   return jresult;
102741 }
102742
102743
102744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102745   unsigned int jresult ;
102746   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102747   unsigned int result;
102748
102749   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102750   {
102751     try {
102752       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102753     } catch (std::out_of_range& e) {
102754       {
102755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102756       };
102757     } catch (std::exception& e) {
102758       {
102759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102760       };
102761     } catch (...) {
102762       {
102763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102764       };
102765     }
102766   }
102767   jresult = result;
102768   return jresult;
102769 }
102770
102771
102772 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102773   int jresult ;
102774   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102775   Dali::Pixel::Format result;
102776
102777   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102778   {
102779     try {
102780       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102781     } catch (std::out_of_range& e) {
102782       {
102783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102784       };
102785     } catch (std::exception& e) {
102786       {
102787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102788       };
102789     } catch (...) {
102790       {
102791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102792       };
102793     }
102794   }
102795   jresult = (int)result;
102796   return jresult;
102797 }
102798
102799
102800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102801   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102802   Dali::Devel::PixelBuffer arg2 ;
102803   float arg3 ;
102804   bool arg4 ;
102805   Dali::Devel::PixelBuffer *argp2 ;
102806
102807   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102808   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102809   if (!argp2) {
102810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102811     return ;
102812   }
102813   arg2 = *argp2;
102814   arg3 = (float)jarg3;
102815   arg4 = jarg4 ? true : false;
102816   {
102817     try {
102818       (arg1)->ApplyMask(arg2,arg3,arg4);
102819     } catch (std::out_of_range& e) {
102820       {
102821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102822       };
102823     } catch (std::exception& e) {
102824       {
102825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102826       };
102827     } catch (...) {
102828       {
102829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102830       };
102831     }
102832   }
102833 }
102834
102835
102836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102837   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102838   Dali::Devel::PixelBuffer arg2 ;
102839   float arg3 ;
102840   Dali::Devel::PixelBuffer *argp2 ;
102841
102842   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102843   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102844   if (!argp2) {
102845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102846     return ;
102847   }
102848   arg2 = *argp2;
102849   arg3 = (float)jarg3;
102850   {
102851     try {
102852       (arg1)->ApplyMask(arg2,arg3);
102853     } catch (std::out_of_range& e) {
102854       {
102855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102856       };
102857     } catch (std::exception& e) {
102858       {
102859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102860       };
102861     } catch (...) {
102862       {
102863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102864       };
102865     }
102866   }
102867 }
102868
102869
102870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102871   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102872   Dali::Devel::PixelBuffer arg2 ;
102873   Dali::Devel::PixelBuffer *argp2 ;
102874
102875   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102876   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102877   if (!argp2) {
102878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102879     return ;
102880   }
102881   arg2 = *argp2;
102882   {
102883     try {
102884       (arg1)->ApplyMask(arg2);
102885     } catch (std::out_of_range& e) {
102886       {
102887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102888       };
102889     } catch (std::exception& e) {
102890       {
102891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102892       };
102893     } catch (...) {
102894       {
102895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102896       };
102897     }
102898   }
102899 }
102900
102901
102902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102903   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102904   float arg2 ;
102905
102906   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102907   arg2 = (float)jarg2;
102908   {
102909     try {
102910       (arg1)->ApplyGaussianBlur(arg2);
102911     } catch (std::out_of_range& e) {
102912       {
102913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102914       };
102915     } catch (std::exception& e) {
102916       {
102917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102918       };
102919     } catch (...) {
102920       {
102921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102922       };
102923     }
102924   }
102925 }
102926
102927
102928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102929   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102930   uint16_t arg2 ;
102931   uint16_t arg3 ;
102932   uint16_t arg4 ;
102933   uint16_t arg5 ;
102934
102935   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102936   arg2 = (uint16_t)jarg2;
102937   arg3 = (uint16_t)jarg3;
102938   arg4 = (uint16_t)jarg4;
102939   arg5 = (uint16_t)jarg5;
102940   {
102941     try {
102942       (arg1)->Crop(arg2,arg3,arg4,arg5);
102943     } catch (std::out_of_range& e) {
102944       {
102945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102946       };
102947     } catch (std::exception& e) {
102948       {
102949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102950       };
102951     } catch (...) {
102952       {
102953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102954       };
102955     }
102956   }
102957 }
102958
102959
102960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102961   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102962   uint16_t arg2 ;
102963   uint16_t arg3 ;
102964
102965   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102966   arg2 = (uint16_t)jarg2;
102967   arg3 = (uint16_t)jarg3;
102968   {
102969     try {
102970       (arg1)->Resize(arg2,arg3);
102971     } catch (std::out_of_range& e) {
102972       {
102973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102974       };
102975     } catch (std::exception& e) {
102976       {
102977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102978       };
102979     } catch (...) {
102980       {
102981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102982       };
102983     }
102984   }
102985 }
102986
102987
102988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102989   void * jresult ;
102990   std::string *arg1 = 0 ;
102991   Dali::ImageDimensions arg2 ;
102992   Dali::FittingMode::Type arg3 ;
102993   Dali::SamplingMode::Type arg4 ;
102994   bool arg5 ;
102995   Dali::ImageDimensions *argp2 ;
102996   Dali::Devel::PixelBuffer result;
102997
102998   if (!jarg1) {
102999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103000     return 0;
103001   }
103002   std::string arg1_str(jarg1);
103003   arg1 = &arg1_str;
103004   argp2 = (Dali::ImageDimensions *)jarg2;
103005   if (!argp2) {
103006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103007     return 0;
103008   }
103009   arg2 = *argp2;
103010   arg3 = (Dali::FittingMode::Type)jarg3;
103011   arg4 = (Dali::SamplingMode::Type)jarg4;
103012   arg5 = jarg5 ? true : false;
103013   {
103014     try {
103015       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103016     } catch (std::out_of_range& e) {
103017       {
103018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103019       };
103020     } catch (std::exception& e) {
103021       {
103022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103023       };
103024     } catch (...) {
103025       {
103026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103027       };
103028     }
103029   }
103030   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103031
103032   return jresult;
103033 }
103034
103035
103036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103037   void * jresult ;
103038   std::string *arg1 = 0 ;
103039   Dali::ImageDimensions arg2 ;
103040   Dali::FittingMode::Type arg3 ;
103041   Dali::SamplingMode::Type arg4 ;
103042   Dali::ImageDimensions *argp2 ;
103043   Dali::Devel::PixelBuffer result;
103044
103045   if (!jarg1) {
103046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103047     return 0;
103048   }
103049   std::string arg1_str(jarg1);
103050   arg1 = &arg1_str;
103051   argp2 = (Dali::ImageDimensions *)jarg2;
103052   if (!argp2) {
103053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103054     return 0;
103055   }
103056   arg2 = *argp2;
103057   arg3 = (Dali::FittingMode::Type)jarg3;
103058   arg4 = (Dali::SamplingMode::Type)jarg4;
103059   {
103060     try {
103061       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103062     } catch (std::out_of_range& e) {
103063       {
103064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103065       };
103066     } catch (std::exception& e) {
103067       {
103068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103069       };
103070     } catch (...) {
103071       {
103072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103073       };
103074     }
103075   }
103076   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103077
103078   return jresult;
103079 }
103080
103081
103082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103083   void * jresult ;
103084   std::string *arg1 = 0 ;
103085   Dali::ImageDimensions arg2 ;
103086   Dali::FittingMode::Type arg3 ;
103087   Dali::ImageDimensions *argp2 ;
103088   Dali::Devel::PixelBuffer result;
103089
103090   if (!jarg1) {
103091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103092     return 0;
103093   }
103094   std::string arg1_str(jarg1);
103095   arg1 = &arg1_str;
103096   argp2 = (Dali::ImageDimensions *)jarg2;
103097   if (!argp2) {
103098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103099     return 0;
103100   }
103101   arg2 = *argp2;
103102   arg3 = (Dali::FittingMode::Type)jarg3;
103103   {
103104     try {
103105       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103106     } catch (std::out_of_range& e) {
103107       {
103108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103109       };
103110     } catch (std::exception& e) {
103111       {
103112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103113       };
103114     } catch (...) {
103115       {
103116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103117       };
103118     }
103119   }
103120   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103121
103122   return jresult;
103123 }
103124
103125
103126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103127   void * jresult ;
103128   std::string *arg1 = 0 ;
103129   Dali::ImageDimensions arg2 ;
103130   Dali::ImageDimensions *argp2 ;
103131   Dali::Devel::PixelBuffer result;
103132
103133   if (!jarg1) {
103134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103135     return 0;
103136   }
103137   std::string arg1_str(jarg1);
103138   arg1 = &arg1_str;
103139   argp2 = (Dali::ImageDimensions *)jarg2;
103140   if (!argp2) {
103141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103142     return 0;
103143   }
103144   arg2 = *argp2;
103145   {
103146     try {
103147       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103148     } catch (std::out_of_range& e) {
103149       {
103150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103151       };
103152     } catch (std::exception& e) {
103153       {
103154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103155       };
103156     } catch (...) {
103157       {
103158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103159       };
103160     }
103161   }
103162   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103163
103164   return jresult;
103165 }
103166
103167
103168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103169   void * jresult ;
103170   std::string *arg1 = 0 ;
103171   Dali::Devel::PixelBuffer result;
103172
103173   if (!jarg1) {
103174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103175     return 0;
103176   }
103177   std::string arg1_str(jarg1);
103178   arg1 = &arg1_str;
103179   {
103180     try {
103181       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103182     } catch (std::out_of_range& e) {
103183       {
103184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103185       };
103186     } catch (std::exception& e) {
103187       {
103188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103189       };
103190     } catch (...) {
103191       {
103192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103193       };
103194     }
103195   }
103196   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103197
103198   return jresult;
103199 }
103200
103201
103202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103203   void * jresult ;
103204   std::string *arg1 = 0 ;
103205   Dali::ImageDimensions arg2 ;
103206   Dali::FittingMode::Type arg3 ;
103207   Dali::SamplingMode::Type arg4 ;
103208   bool arg5 ;
103209   Dali::ImageDimensions *argp2 ;
103210   Dali::ImageDimensions result;
103211
103212   if (!jarg1) {
103213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103214     return 0;
103215   }
103216   std::string arg1_str(jarg1);
103217   arg1 = &arg1_str;
103218   argp2 = (Dali::ImageDimensions *)jarg2;
103219   if (!argp2) {
103220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103221     return 0;
103222   }
103223   arg2 = *argp2;
103224   arg3 = (Dali::FittingMode::Type)jarg3;
103225   arg4 = (Dali::SamplingMode::Type)jarg4;
103226   arg5 = jarg5 ? true : false;
103227   {
103228     try {
103229       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103230     } catch (std::out_of_range& e) {
103231       {
103232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103233       };
103234     } catch (std::exception& e) {
103235       {
103236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103237       };
103238     } catch (...) {
103239       {
103240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103241       };
103242     }
103243   }
103244   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103245
103246   return jresult;
103247 }
103248
103249
103250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103251   void * jresult ;
103252   std::string *arg1 = 0 ;
103253   Dali::ImageDimensions arg2 ;
103254   Dali::FittingMode::Type arg3 ;
103255   Dali::SamplingMode::Type arg4 ;
103256   Dali::ImageDimensions *argp2 ;
103257   Dali::ImageDimensions result;
103258
103259   if (!jarg1) {
103260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103261     return 0;
103262   }
103263   std::string arg1_str(jarg1);
103264   arg1 = &arg1_str;
103265   argp2 = (Dali::ImageDimensions *)jarg2;
103266   if (!argp2) {
103267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103268     return 0;
103269   }
103270   arg2 = *argp2;
103271   arg3 = (Dali::FittingMode::Type)jarg3;
103272   arg4 = (Dali::SamplingMode::Type)jarg4;
103273   {
103274     try {
103275       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103276     } catch (std::out_of_range& e) {
103277       {
103278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103279       };
103280     } catch (std::exception& e) {
103281       {
103282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103283       };
103284     } catch (...) {
103285       {
103286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103287       };
103288     }
103289   }
103290   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103291
103292   return jresult;
103293 }
103294
103295
103296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103297   void * jresult ;
103298   std::string *arg1 = 0 ;
103299   Dali::ImageDimensions arg2 ;
103300   Dali::FittingMode::Type arg3 ;
103301   Dali::ImageDimensions *argp2 ;
103302   Dali::ImageDimensions result;
103303
103304   if (!jarg1) {
103305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103306     return 0;
103307   }
103308   std::string arg1_str(jarg1);
103309   arg1 = &arg1_str;
103310   argp2 = (Dali::ImageDimensions *)jarg2;
103311   if (!argp2) {
103312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103313     return 0;
103314   }
103315   arg2 = *argp2;
103316   arg3 = (Dali::FittingMode::Type)jarg3;
103317   {
103318     try {
103319       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103320     } catch (std::out_of_range& e) {
103321       {
103322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103323       };
103324     } catch (std::exception& e) {
103325       {
103326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103327       };
103328     } catch (...) {
103329       {
103330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103331       };
103332     }
103333   }
103334   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103335
103336   return jresult;
103337 }
103338
103339
103340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103341   void * jresult ;
103342   std::string *arg1 = 0 ;
103343   Dali::ImageDimensions arg2 ;
103344   Dali::ImageDimensions *argp2 ;
103345   Dali::ImageDimensions result;
103346
103347   if (!jarg1) {
103348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103349     return 0;
103350   }
103351   std::string arg1_str(jarg1);
103352   arg1 = &arg1_str;
103353   argp2 = (Dali::ImageDimensions *)jarg2;
103354   if (!argp2) {
103355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103356     return 0;
103357   }
103358   arg2 = *argp2;
103359   {
103360     try {
103361       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103362     } catch (std::out_of_range& e) {
103363       {
103364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103365       };
103366     } catch (std::exception& e) {
103367       {
103368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103369       };
103370     } catch (...) {
103371       {
103372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103373       };
103374     }
103375   }
103376   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103377
103378   return jresult;
103379 }
103380
103381
103382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103383   void * jresult ;
103384   std::string *arg1 = 0 ;
103385   Dali::ImageDimensions result;
103386
103387   if (!jarg1) {
103388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103389     return 0;
103390   }
103391   std::string arg1_str(jarg1);
103392   arg1 = &arg1_str;
103393   {
103394     try {
103395       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103396     } catch (std::out_of_range& e) {
103397       {
103398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103399       };
103400     } catch (std::exception& e) {
103401       {
103402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103403       };
103404     } catch (...) {
103405       {
103406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103407       };
103408     }
103409   }
103410   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103411
103412   return jresult;
103413 }
103414
103415
103416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103417   void * jresult ;
103418   std::string *arg1 = 0 ;
103419   Dali::ImageDimensions arg2 ;
103420   Dali::FittingMode::Type arg3 ;
103421   Dali::SamplingMode::Type arg4 ;
103422   bool arg5 ;
103423   Dali::ImageDimensions *argp2 ;
103424   Dali::Devel::PixelBuffer result;
103425
103426   if (!jarg1) {
103427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103428     return 0;
103429   }
103430   std::string arg1_str(jarg1);
103431   arg1 = &arg1_str;
103432   argp2 = (Dali::ImageDimensions *)jarg2;
103433   if (!argp2) {
103434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103435     return 0;
103436   }
103437   arg2 = *argp2;
103438   arg3 = (Dali::FittingMode::Type)jarg3;
103439   arg4 = (Dali::SamplingMode::Type)jarg4;
103440   arg5 = jarg5 ? true : false;
103441   {
103442     try {
103443       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103444     } catch (std::out_of_range& e) {
103445       {
103446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103447       };
103448     } catch (std::exception& e) {
103449       {
103450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103451       };
103452     } catch (...) {
103453       {
103454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103455       };
103456     }
103457   }
103458   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103459
103460   return jresult;
103461 }
103462
103463
103464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103465   void * jresult ;
103466   std::string *arg1 = 0 ;
103467   Dali::ImageDimensions arg2 ;
103468   Dali::FittingMode::Type arg3 ;
103469   Dali::SamplingMode::Type arg4 ;
103470   Dali::ImageDimensions *argp2 ;
103471   Dali::Devel::PixelBuffer result;
103472
103473   if (!jarg1) {
103474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103475     return 0;
103476   }
103477   std::string arg1_str(jarg1);
103478   arg1 = &arg1_str;
103479   argp2 = (Dali::ImageDimensions *)jarg2;
103480   if (!argp2) {
103481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103482     return 0;
103483   }
103484   arg2 = *argp2;
103485   arg3 = (Dali::FittingMode::Type)jarg3;
103486   arg4 = (Dali::SamplingMode::Type)jarg4;
103487   {
103488     try {
103489       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103490     } catch (std::out_of_range& e) {
103491       {
103492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103493       };
103494     } catch (std::exception& e) {
103495       {
103496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103497       };
103498     } catch (...) {
103499       {
103500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103501       };
103502     }
103503   }
103504   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103505
103506   return jresult;
103507 }
103508
103509
103510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103511   void * jresult ;
103512   std::string *arg1 = 0 ;
103513   Dali::ImageDimensions arg2 ;
103514   Dali::FittingMode::Type arg3 ;
103515   Dali::ImageDimensions *argp2 ;
103516   Dali::Devel::PixelBuffer result;
103517
103518   if (!jarg1) {
103519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103520     return 0;
103521   }
103522   std::string arg1_str(jarg1);
103523   arg1 = &arg1_str;
103524   argp2 = (Dali::ImageDimensions *)jarg2;
103525   if (!argp2) {
103526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103527     return 0;
103528   }
103529   arg2 = *argp2;
103530   arg3 = (Dali::FittingMode::Type)jarg3;
103531   {
103532     try {
103533       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103534     } catch (std::out_of_range& e) {
103535       {
103536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103537       };
103538     } catch (std::exception& e) {
103539       {
103540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103541       };
103542     } catch (...) {
103543       {
103544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103545       };
103546     }
103547   }
103548   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103549
103550   return jresult;
103551 }
103552
103553
103554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103555   void * jresult ;
103556   std::string *arg1 = 0 ;
103557   Dali::ImageDimensions arg2 ;
103558   Dali::ImageDimensions *argp2 ;
103559   Dali::Devel::PixelBuffer result;
103560
103561   if (!jarg1) {
103562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103563     return 0;
103564   }
103565   std::string arg1_str(jarg1);
103566   arg1 = &arg1_str;
103567   argp2 = (Dali::ImageDimensions *)jarg2;
103568   if (!argp2) {
103569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103570     return 0;
103571   }
103572   arg2 = *argp2;
103573   {
103574     try {
103575       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103576     } catch (std::out_of_range& e) {
103577       {
103578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103579       };
103580     } catch (std::exception& e) {
103581       {
103582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103583       };
103584     } catch (...) {
103585       {
103586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103587       };
103588     }
103589   }
103590   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103591
103592   return jresult;
103593 }
103594
103595
103596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103597   void * jresult ;
103598   std::string *arg1 = 0 ;
103599   Dali::Devel::PixelBuffer result;
103600
103601   if (!jarg1) {
103602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103603     return 0;
103604   }
103605   std::string arg1_str(jarg1);
103606   arg1 = &arg1_str;
103607   {
103608     try {
103609       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103610     } catch (std::out_of_range& e) {
103611       {
103612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103613       };
103614     } catch (std::exception& e) {
103615       {
103616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103617       };
103618     } catch (...) {
103619       {
103620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103621       };
103622     }
103623   }
103624   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103625
103626   return jresult;
103627 }
103628
103629
103630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103631   unsigned int arg1 ;
103632
103633   arg1 = (unsigned int)jarg1;
103634   {
103635     try {
103636       Dali::SetMaxTextureSize(arg1);
103637     } catch (std::out_of_range& e) {
103638       {
103639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103640       };
103641     } catch (std::exception& e) {
103642       {
103643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103644       };
103645     } catch (...) {
103646       {
103647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103648       };
103649     }
103650   }
103651 }
103652
103653
103654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103655   unsigned int jresult ;
103656   unsigned int result;
103657
103658   {
103659     try {
103660       result = (unsigned int)Dali::GetMaxTextureSize();
103661     } catch (std::out_of_range& e) {
103662       {
103663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103664       };
103665     } catch (std::exception& e) {
103666       {
103667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103668       };
103669     } catch (...) {
103670       {
103671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103672       };
103673     }
103674   }
103675   jresult = result;
103676   return jresult;
103677 }
103678
103679
103680 #ifdef __cplusplus
103681 }
103682 #endif
103683