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
 428 #include <dali/public-api/math/matrix.h>
 429 #include <dali/public-api/math/matrix3.h>
 430 #include <dali/public-api/math/viewport.h>
 431 #include <dali/public-api/object/property-key.h>
 432 #include <dali/devel-api/object/csharp-type-info.h>
 433 #include <dali/devel-api/object/csharp-type-registry.h>
 434
 435 #include <dali/public-api/adaptor-framework/timer.h>
 436 #include <dali/public-api/adaptor-framework/style-change.h>
 437 #include <dali/devel-api/adaptor-framework/drag-and-drop-detector.h>
 438 #include <dali/devel-api/adaptor-framework/application-extensions.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 // add here SWIG version check
 473
 474 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 475 // disable Swig-dependent warnings
 476
 477 // 'identifier1' has C-linkage specified,
 478 // but returns UDT 'identifier2' which is incompatible with C
 479 #pragma warning(disable: 4190)
 480
 481 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 482 #pragma warning(disable: 4800)
 483
 484 // debug info too long etc etc
 485 #pragma warning(disable: 4786)
 486 #endif
 487
 488
 489 #include <stdexcept>
 490
 491
 492 #include <string>
 493
 494
 495 #include <vector>
 496 #include <algorithm>
 497 #include <stdexcept>
 498
 499
 500 #include <map>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <utility>
 506
 507
 508 typedef float floatp;
 509
 510 SWIGINTERN floatp *new_floatp(){
 511   return new float();
 512 }
 513 SWIGINTERN void delete_floatp(floatp *self){
 514   if (self) delete self;
 515 }
 516 SWIGINTERN void floatp_assign(floatp *self,float value){
 517   *self = value;
 518 }
 519 SWIGINTERN float floatp_value(floatp *self){
 520   return *self;
 521 }
 522 SWIGINTERN float *floatp_cast(floatp *self){
 523   return self;
 524 }
 525 SWIGINTERN floatp *floatp_frompointer(float *t){
 526   return (floatp *) t;
 527 }
 528
 529 typedef int intp;
 530
 531 SWIGINTERN intp *new_intp(){
 532   return new int();
 533 }
 534 SWIGINTERN void delete_intp(intp *self){
 535   if (self) delete self;
 536 }
 537 SWIGINTERN void intp_assign(intp *self,int value){
 538   *self = value;
 539 }
 540 SWIGINTERN int intp_value(intp *self){
 541   return *self;
 542 }
 543 SWIGINTERN int *intp_cast(intp *self){
 544   return self;
 545 }
 546 SWIGINTERN intp *intp_frompointer(int *t){
 547   return (intp *) t;
 548 }
 549
 550 typedef double doublep;
 551
 552 SWIGINTERN doublep *new_doublep(){
 553   return new double();
 554 }
 555 SWIGINTERN void delete_doublep(doublep *self){
 556   if (self) delete self;
 557 }
 558 SWIGINTERN void doublep_assign(doublep *self,double value){
 559   *self = value;
 560 }
 561 SWIGINTERN double doublep_value(doublep *self){
 562   return *self;
 563 }
 564 SWIGINTERN double *doublep_cast(doublep *self){
 565   return self;
 566 }
 567 SWIGINTERN doublep *doublep_frompointer(double *t){
 568   return (doublep *) t;
 569 }
 570
 571 typedef unsigned int uintp;
 572
 573 SWIGINTERN uintp *new_uintp(){
 574   return new unsigned int();
 575 }
 576 SWIGINTERN void delete_uintp(uintp *self){
 577   if (self) delete self;
 578 }
 579 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 580   *self = value;
 581 }
 582 SWIGINTERN unsigned int uintp_value(uintp *self){
 583   return *self;
 584 }
 585 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 586   return self;
 587 }
 588 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 589   return (uintp *) t;
 590 }
 591
 592 typedef unsigned short ushortp;
 593
 594 SWIGINTERN ushortp *new_ushortp(){
 595   return new unsigned short();
 596 }
 597 SWIGINTERN void delete_ushortp(ushortp *self){
 598   if (self) delete self;
 599 }
 600 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 601   *self = value;
 602 }
 603 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 604   return *self;
 605 }
 606 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 607   return self;
 608 }
 609 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 610   return (ushortp *) t;
 611 }
 612
 613 unsigned int int_to_uint(int x) {
 614    return (unsigned int) x;
 615 }
 616
 617
 618 using namespace Dali;
 619 using namespace Dali::Toolkit;
 620
 621 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 622 {
 623   bool result = false;
 624   try
 625   {
 626     // C++ code. DALi uses Handle <-> Body design pattern.
 627     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 628     // Handles in DALi can be converted into a boolean type
 629     // to check if the handle has a valid body attached to it.
 630     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 631     if( *self )
 632     {
 633       result = true;
 634     }
 635     else
 636     {
 637       result = false;
 638     }
 639   }
 640   catch (std::out_of_range& e)
 641   {
 642     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 643     return 0;
 644   }
 645   catch (std::exception& e)
 646   {
 647     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 648     return 0;
 649   }
 650   catch (DaliException e)
 651   {
 652     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 653     return 0;
 654   }
 655   catch (...)
 656   {
 657     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 658     return 0;
 659   }
 660   return result;
 661 }
 662
 663 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 664 {
 665   bool result = false;
 666   try
 667   {
 668     // C++ code. Check if two handles reference the same implemtion
 669     if( *self == rhs)
 670     {
 671       result = true;
 672     }
 673     else
 674     {
 675       result = false;
 676     }
 677   }
 678   catch (std::out_of_range& e)
 679   {
 680     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 681     return 0;
 682   }
 683   catch (std::exception& e)
 684   {
 685     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 686     return 0;
 687   }
 688   catch (DaliException e)
 689   {
 690     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 691     return 0;
 692   }
 693   catch (...)
 694   {
 695     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 696     return 0;
 697   }
 698   return result;
 699 }
 700
 701
 702 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 703      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 704    }
 705 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){
 706      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 707    }
 708 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 709         std::vector< Dali::TouchPoint >* pv = 0;
 710         if (capacity >= 0) {
 711           pv = new std::vector< Dali::TouchPoint >();
 712           pv->reserve(capacity);
 713        } else {
 714           throw std::out_of_range("capacity");
 715        }
 716        return pv;
 717       }
 718 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 719         if (index>=0 && index<(int)self->size())
 720           return (*self)[index];
 721         else
 722           throw std::out_of_range("index");
 723       }
 724 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 725         if (index>=0 && index<(int)self->size())
 726           return (*self)[index];
 727         else
 728           throw std::out_of_range("index");
 729       }
 730 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 731         if (index>=0 && index<(int)self->size())
 732           (*self)[index] = val;
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 737         self->insert(self->end(), values.begin(), values.end());
 738       }
 739 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 740         if (index < 0)
 741           throw std::out_of_range("index");
 742         if (count < 0)
 743           throw std::out_of_range("count");
 744         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 745           throw std::invalid_argument("invalid range");
 746         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 749         if (index>=0 && index<(int)self->size()+1)
 750           self->insert(self->begin()+index, x);
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 755         if (index>=0 && index<(int)self->size()+1)
 756           self->insert(self->begin()+index, values.begin(), values.end());
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 761         if (index>=0 && index<(int)self->size())
 762           self->erase(self->begin() + index);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 767         if (index < 0)
 768           throw std::out_of_range("index");
 769         if (count < 0)
 770           throw std::out_of_range("count");
 771         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 772           throw std::invalid_argument("invalid range");
 773         self->erase(self->begin()+index, self->begin()+index+count);
 774       }
 775 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         return new std::vector< Dali::TouchPoint >(count, value);
 779       }
 780 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 781         std::reverse(self->begin(), self->end());
 782       }
 783 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 784         if (index < 0)
 785           throw std::out_of_range("index");
 786         if (count < 0)
 787           throw std::out_of_range("count");
 788         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 789           throw std::invalid_argument("invalid range");
 790         std::reverse(self->begin()+index, self->begin()+index+count);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 793         if (index < 0)
 794           throw std::out_of_range("index");
 795         if (index+values.size() > self->size())
 796           throw std::out_of_range("index");
 797         std::copy(values.begin(), values.end(), self->begin()+index);
 798       }
 799 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 800          return self->Empty();
 801       }
 802 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 803         return self->GetConnectionCount();
 804       }
 805 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 806           self->Connect( func );
 807       }
 808 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 809           self->Disconnect( func );
 810       }
 811 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 812           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 813 /*@SWIG@*/ self->Emit( arg );
 814       }
 815 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 816          return self->Empty();
 817       }
 818 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 819         return self->GetConnectionCount();
 820       }
 821 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 822           self->Connect( func );
 823       }
 824 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 825           self->Disconnect( func );
 826       }
 827 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 828           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 829 /*@SWIG@*/ self->Emit( arg );
 830       }
 831 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 832          return self->Empty();
 833       }
 834 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){
 835         return self->GetConnectionCount();
 836       }
 837 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 *)){
 838           self->Connect( func );
 839       }
 840 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 *)){
 841           self->Disconnect( func );
 842       }
 843 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){
 844           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 845 /*@SWIG@*/ self->Emit( arg );
 846       }
 847 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 848          return self->Empty();
 849       }
 850 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 851         return self->GetConnectionCount();
 852       }
 853 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 854           self->Connect( func );
 855       }
 856 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 857           self->Disconnect( func );
 858       }
 859 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 860           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 861 /*@SWIG@*/ self->Emit( arg );
 862       }
 863 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 864          return self->Empty();
 865       }
 866 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 867         return self->GetConnectionCount();
 868       }
 869 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 870           self->Connect( func );
 871       }
 872 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 873           self->Disconnect( func );
 874       }
 875 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 876           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 877 /*@SWIG@*/ self->Emit( arg );
 878       }
 879 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){
 880          return self->Empty();
 881       }
 882 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){
 883         return self->GetConnectionCount();
 884       }
 885 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 &)){
 886         self->Connect( func );
 887       }
 888 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 &)){
 889         self->Disconnect( func );
 890       }
 891 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){
 892         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 893 /*@SWIG@*/ self->Emit( arg1, arg2 );
 894       }
 895 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){
 896          return self->Empty();
 897       }
 898 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){
 899         return self->GetConnectionCount();
 900       }
 901 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 &)){
 902         self->Connect( func );
 903       }
 904 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 &)){
 905         self->Disconnect( func );
 906       }
 907 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){
 908         return self->Emit( arg1, arg2 );
 909       }
 910 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){
 911          return self->Empty();
 912       }
 913 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){
 914         return self->GetConnectionCount();
 915       }
 916 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 &)){
 917         self->Connect( func );
 918       }
 919 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 &)){
 920         self->Disconnect( func );
 921       }
 922 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){
 923         return self->Emit( arg1, arg2 );
 924       }
 925 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){
 926          return self->Empty();
 927       }
 928 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){
 929         return self->GetConnectionCount();
 930       }
 931 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 &)){
 932         self->Connect( func );
 933       }
 934 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 &)){
 935         self->Disconnect( func );
 936       }
 937 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){
 938         return self->Emit( arg1, arg2 );
 939       }
 940 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 941          return self->Empty();
 942       }
 943 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 944         return self->GetConnectionCount();
 945       }
 946 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 947           self->Connect( func );
 948       }
 949 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 950           self->Disconnect( func );
 951       }
 952 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 953           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 954 /*@SWIG@*/ self->Emit( arg );
 955       }
 956 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 957          return self->Empty();
 958       }
 959 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){
 960         return self->GetConnectionCount();
 961       }
 962 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 &)){
 963           self->Connect( func );
 964       }
 965 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 &)){
 966           self->Disconnect( func );
 967       }
 968 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){
 969           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 970 /*@SWIG@*/ self->Emit( arg );
 971       }
 972 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 973          return self->Empty();
 974       }
 975 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){
 976         return self->GetConnectionCount();
 977       }
 978 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 &)){
 979           self->Connect( func );
 980       }
 981 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 &)){
 982           self->Disconnect( func );
 983       }
 984 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){
 985           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 986 /*@SWIG@*/ self->Emit( arg );
 987       }
 988 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 989          return self->Empty();
 990       }
 991 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){
 992         return self->GetConnectionCount();
 993       }
 994 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 &)){
 995           self->Connect( func );
 996       }
 997 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 &)){
 998           self->Disconnect( func );
 999       }
1000 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){
1001           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1002 /*@SWIG@*/ self->Emit( arg );
1003       }
1004 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){
1005          return self->Empty();
1006       }
1007 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){
1008         return self->GetConnectionCount();
1009       }
1010 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 &)){
1011         self->Connect( func );
1012       }
1013 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 &)){
1014         self->Disconnect( func );
1015       }
1016 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){
1017         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1018 /*@SWIG@*/ self->Emit( arg1, arg2 );
1019       }
1020 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){
1021          return self->Empty();
1022       }
1023 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){
1024         return self->GetConnectionCount();
1025       }
1026 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 &)){
1027         self->Connect( func );
1028       }
1029 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 &)){
1030         self->Disconnect( func );
1031       }
1032 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){
1033         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1034 /*@SWIG@*/ self->Emit( arg1, arg2 );
1035       }
1036 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){
1037          return self->Empty();
1038       }
1039 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){
1040         return self->GetConnectionCount();
1041       }
1042 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 &)){
1043         self->Connect( func );
1044       }
1045 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 &)){
1046         self->Disconnect( func );
1047       }
1048 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){
1049         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1050 /*@SWIG@*/ self->Emit( arg1, arg2 );
1051       }
1052 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1053          return self->Empty();
1054       }
1055 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1056         return self->GetConnectionCount();
1057       }
1058 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1059           self->Connect( func );
1060       }
1061 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1062           self->Disconnect( func );
1063       }
1064 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1065           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1066 /*@SWIG@*/ self->Emit( arg );
1067       }
1068 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){
1069          return self->Empty();
1070       }
1071 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){
1072         return self->GetConnectionCount();
1073       }
1074 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)){
1075           return self->Connect( func );
1076       }
1077 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)){
1078           self->Disconnect( func );
1079       }
1080 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){
1081           self->Emit( arg1, arg3 );
1082       }
1083 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){
1084          return self->Empty();
1085       }
1086 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){
1087         return self->GetConnectionCount();
1088       }
1089 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)){
1090           return self->Connect( func );
1091       }
1092 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)){
1093           self->Disconnect( func );
1094       }
1095 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){
1096           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1097 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1098       }
1099
1100 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1101          return self->Empty();
1102       }
1103 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1104         return self->GetConnectionCount();
1105       }
1106 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1107           self->Connect( func );
1108       }
1109 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1110           self->Disconnect( func );
1111       }
1112 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1113           return self->Emit();
1114       }
1115
1116 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1117         std::vector< unsigned int >* pv = 0;
1118         if (capacity >= 0) {
1119           pv = new std::vector< unsigned int >();
1120           pv->reserve(capacity);
1121        } else {
1122           throw std::out_of_range("capacity");
1123        }
1124        return pv;
1125       }
1126 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1127         if (index>=0 && index<(int)self->size())
1128           return (*self)[index];
1129         else
1130           throw std::out_of_range("index");
1131       }
1132 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1133         if (index>=0 && index<(int)self->size())
1134           return (*self)[index];
1135         else
1136           throw std::out_of_range("index");
1137       }
1138 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1139         if (index>=0 && index<(int)self->size())
1140           (*self)[index] = val;
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1145         self->insert(self->end(), values.begin(), values.end());
1146       }
1147 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1148         if (index < 0)
1149           throw std::out_of_range("index");
1150         if (count < 0)
1151           throw std::out_of_range("count");
1152         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1153           throw std::invalid_argument("invalid range");
1154         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1157         if (index>=0 && index<(int)self->size()+1)
1158           self->insert(self->begin()+index, x);
1159         else
1160           throw std::out_of_range("index");
1161       }
1162 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1163         if (index>=0 && index<(int)self->size()+1)
1164           self->insert(self->begin()+index, values.begin(), values.end());
1165         else
1166           throw std::out_of_range("index");
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1169         if (index>=0 && index<(int)self->size())
1170           self->erase(self->begin() + index);
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1175         if (index < 0)
1176           throw std::out_of_range("index");
1177         if (count < 0)
1178           throw std::out_of_range("count");
1179         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1180           throw std::invalid_argument("invalid range");
1181         self->erase(self->begin()+index, self->begin()+index+count);
1182       }
1183 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         return new std::vector< unsigned int >(count, value);
1187       }
1188 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1189         std::reverse(self->begin(), self->end());
1190       }
1191 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1192         if (index < 0)
1193           throw std::out_of_range("index");
1194         if (count < 0)
1195           throw std::out_of_range("count");
1196         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1197           throw std::invalid_argument("invalid range");
1198         std::reverse(self->begin()+index, self->begin()+index+count);
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1201         if (index < 0)
1202           throw std::out_of_range("index");
1203         if (index+values.size() > self->size())
1204           throw std::out_of_range("index");
1205         std::copy(values.begin(), values.end(), self->begin()+index);
1206       }
1207 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1208         return std::find(self->begin(), self->end(), value) != self->end();
1209       }
1210 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1211         int index = -1;
1212         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1213         if (it != self->end())
1214           index = (int)(it - self->begin());
1215         return index;
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1220         if (rit != self->rend())
1221           index = (int)(self->rend() - 1 - rit);
1222         return index;
1223       }
1224 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1225         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1226         if (it != self->end()) {
1227           self->erase(it);
1228           return true;
1229         }
1230         return false;
1231       }
1232 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){
1233         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1234         if (capacity >= 0) {
1235           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1236           pv->reserve(capacity);
1237        } else {
1238           throw std::out_of_range("capacity");
1239        }
1240        return pv;
1241       }
1242 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){
1243         if (index>=0 && index<(int)self->size())
1244           return (*self)[index];
1245         else
1246           throw std::out_of_range("index");
1247       }
1248 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){
1249         if (index>=0 && index<(int)self->size())
1250           return (*self)[index];
1251         else
1252           throw std::out_of_range("index");
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           (*self)[index] = val;
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         self->insert(self->end(), values.begin(), values.end());
1262       }
1263 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){
1264         if (index < 0)
1265           throw std::out_of_range("index");
1266         if (count < 0)
1267           throw std::out_of_range("count");
1268         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1269           throw std::invalid_argument("invalid range");
1270         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1271       }
1272 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){
1273         if (index>=0 && index<(int)self->size()+1)
1274           self->insert(self->begin()+index, x);
1275         else
1276           throw std::out_of_range("index");
1277       }
1278 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){
1279         if (index>=0 && index<(int)self->size()+1)
1280           self->insert(self->begin()+index, values.begin(), values.end());
1281         else
1282           throw std::out_of_range("index");
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size())
1286           self->erase(self->begin() + index);
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
1291         if (index < 0)
1292           throw std::out_of_range("index");
1293         if (count < 0)
1294           throw std::out_of_range("count");
1295         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1296           throw std::invalid_argument("invalid range");
1297         self->erase(self->begin()+index, self->begin()+index+count);
1298       }
1299 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){
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1303       }
1304 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){
1305         std::reverse(self->begin(), self->end());
1306       }
1307 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){
1308         if (index < 0)
1309           throw std::out_of_range("index");
1310         if (count < 0)
1311           throw std::out_of_range("count");
1312         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1313           throw std::invalid_argument("invalid range");
1314         std::reverse(self->begin()+index, self->begin()+index+count);
1315       }
1316 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){
1317         if (index < 0)
1318           throw std::out_of_range("index");
1319         if (index+values.size() > self->size())
1320           throw std::out_of_range("index");
1321         std::copy(values.begin(), values.end(), self->begin()+index);
1322       }
1323 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1324         std::vector< Dali::Actor >* pv = 0;
1325         if (capacity >= 0) {
1326           pv = new std::vector< Dali::Actor >();
1327           pv->reserve(capacity);
1328        } else {
1329           throw std::out_of_range("capacity");
1330        }
1331        return pv;
1332       }
1333 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1334         if (index>=0 && index<(int)self->size())
1335           return (*self)[index];
1336         else
1337           throw std::out_of_range("index");
1338       }
1339 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1340         if (index>=0 && index<(int)self->size())
1341           return (*self)[index];
1342         else
1343           throw std::out_of_range("index");
1344       }
1345 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1346         if (index>=0 && index<(int)self->size())
1347           (*self)[index] = val;
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1352         self->insert(self->end(), values.begin(), values.end());
1353       }
1354 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1355         if (index < 0)
1356           throw std::out_of_range("index");
1357         if (count < 0)
1358           throw std::out_of_range("count");
1359         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1360           throw std::invalid_argument("invalid range");
1361         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1364         if (index>=0 && index<(int)self->size()+1)
1365           self->insert(self->begin()+index, x);
1366         else
1367           throw std::out_of_range("index");
1368       }
1369 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1370         if (index>=0 && index<(int)self->size()+1)
1371           self->insert(self->begin()+index, values.begin(), values.end());
1372         else
1373           throw std::out_of_range("index");
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1376         if (index>=0 && index<(int)self->size())
1377           self->erase(self->begin() + index);
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1382         if (index < 0)
1383           throw std::out_of_range("index");
1384         if (count < 0)
1385           throw std::out_of_range("count");
1386         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1387           throw std::invalid_argument("invalid range");
1388         self->erase(self->begin()+index, self->begin()+index+count);
1389       }
1390 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         return new std::vector< Dali::Actor >(count, value);
1394       }
1395 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1396         std::reverse(self->begin(), self->end());
1397       }
1398 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1399         if (index < 0)
1400           throw std::out_of_range("index");
1401         if (count < 0)
1402           throw std::out_of_range("count");
1403         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1404           throw std::invalid_argument("invalid range");
1405         std::reverse(self->begin()+index, self->begin()+index+count);
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1408         if (index < 0)
1409           throw std::out_of_range("index");
1410         if (index+values.size() > self->size())
1411           throw std::out_of_range("index");
1412         std::copy(values.begin(), values.end(), self->begin()+index);
1413       }
1414 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1415          return self->Empty();
1416       }
1417 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1418         return self->GetConnectionCount();
1419       }
1420 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 &)){
1421           self->Connect( func );
1422       }
1423 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 &)){
1424           self->Disconnect( func );
1425       }
1426 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){
1427           return self->Emit( arg );
1428       }
1429 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){
1430          return self->Empty();
1431       }
1432 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){
1433         return self->GetConnectionCount();
1434       }
1435 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)){
1436         self->Connect( func );
1437       }
1438 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)){
1439         self->Disconnect( func );
1440       }
1441 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){
1442         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1443 /*@SWIG@*/ self->Emit( arg1, arg2 );
1444       }
1445 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1446          return self->Empty();
1447       }
1448 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){
1449         return self->GetConnectionCount();
1450       }
1451 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)){
1452         self->Connect( func );
1453       }
1454 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)){
1455         self->Disconnect( func );
1456       }
1457 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){
1458         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1459 /*@SWIG@*/ self->Emit( arg1, arg2 );
1460       }
1461 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1462          return self->Empty();
1463       }
1464 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1465         return self->GetConnectionCount();
1466       }
1467 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)){
1468         self->Connect( func );
1469       }
1470 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)){
1471         self->Disconnect( func );
1472       }
1473 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){
1474         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1475 /*@SWIG@*/ self->Emit( arg1, arg2 );
1476       }
1477 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){
1478          return self->Empty();
1479       }
1480 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){
1481         return self->GetConnectionCount();
1482       }
1483 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)){
1484         self->Connect( func );
1485       }
1486 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)){
1487         self->Disconnect( func );
1488       }
1489 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){
1490         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1491 /*@SWIG@*/ self->Emit( arg1, arg2 );
1492       }
1493 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1494          return self->Empty();
1495       }
1496 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1497         return self->GetConnectionCount();
1498       }
1499 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)){
1500           self->Connect( func );
1501       }
1502 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)){
1503           self->Disconnect( func );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1506           return self->Emit( arg );
1507       }
1508 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1509          return self->Empty();
1510       }
1511 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1512         return self->GetConnectionCount();
1513       }
1514 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)){
1515           self->Connect( func );
1516       }
1517 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)){
1518           self->Disconnect( func );
1519       }
1520 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1521           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1522 /*@SWIG@*/ self->Emit( arg );
1523       }
1524 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){
1525          return self->Empty();
1526       }
1527 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){
1528         return self->GetConnectionCount();
1529       }
1530 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)){
1531           return self->Connect( func );
1532       }
1533 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)){
1534           self->Disconnect( func );
1535       }
1536 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){
1537           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1538 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1539       }
1540 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1541          return self->Empty();
1542       }
1543 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1544         return self->GetConnectionCount();
1545       }
1546 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)){
1547           self->Connect( func );
1548       }
1549 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)){
1550           self->Disconnect( func );
1551       }
1552 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1553           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1554 /*@SWIG@*/ self->Emit( arg );
1555       }
1556 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){
1557          return self->Empty();
1558       }
1559 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){
1560         return self->GetConnectionCount();
1561       }
1562 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)){
1563           return self->Connect( func );
1564       }
1565 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)){
1566           self->Disconnect( func );
1567       }
1568 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){
1569           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1570 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1571       }
1572 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){
1573          return self->Empty();
1574       }
1575 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){
1576         return self->GetConnectionCount();
1577       }
1578 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 &)){
1579           self->Connect( func );
1580       }
1581 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 &)){
1582           self->Disconnect( func );
1583       }
1584 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){
1585           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1586 /*@SWIG@*/ self->Emit( arg );
1587       }
1588 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1589          return self->Empty();
1590       }
1591 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){
1592         return self->GetConnectionCount();
1593       }
1594 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 &)){
1595           self->Connect( func );
1596       }
1597 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 &)){
1598           self->Disconnect( func );
1599       }
1600 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){
1601           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1602 /*@SWIG@*/ self->Emit( arg );
1603       }
1604
1605
1606 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){
1607          return self->Empty();
1608       }
1609 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){
1610         return self->GetConnectionCount();
1611       }
1612 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 &)){
1613         self->Connect( func );
1614       }
1615 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 &)){
1616         self->Disconnect( func );
1617       }
1618 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){
1619         return self->Emit( arg1, arg2 );
1620       }
1621 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1622          return self->Empty();
1623       }
1624 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1625         return self->GetConnectionCount();
1626       }
1627 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)){
1628           self->Connect( func );
1629       }
1630 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)){
1631           self->Disconnect( func );
1632       }
1633 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1634           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1635 /*@SWIG@*/ self->Emit( arg );
1636       }
1637 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1638          return self->Empty();
1639       }
1640 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1641         return self->GetConnectionCount();
1642       }
1643 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 &)){
1644           self->Connect( func );
1645       }
1646 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 &)){
1647           self->Disconnect( func );
1648       }
1649 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){
1650           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1651 /*@SWIG@*/ self->Emit( arg );
1652       }
1653 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1654          return self->Empty();
1655       }
1656 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){
1657         return self->GetConnectionCount();
1658       }
1659 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)){
1660         self->Connect( func );
1661       }
1662 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)){
1663         self->Disconnect( func );
1664       }
1665 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){
1666         return self->Emit( arg1, arg2 );
1667       }
1668 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1669          return self->Empty();
1670       }
1671 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){
1672         return self->GetConnectionCount();
1673       }
1674 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)){
1675         self->Connect( func );
1676       }
1677 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)){
1678         self->Disconnect( func );
1679       }
1680 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){
1681         return self->Emit( arg1, arg2 );
1682       }
1683
1684
1685 /* ---------------------------------------------------
1686  * C++ director class methods
1687  * --------------------------------------------------- */
1688
1689 #include "dali_wrap.h"
1690
1691 /*
1692  *  Widget director
1693  */
1694 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1695   swig_init_callbacks();
1696 }
1697
1698 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1699 }
1700
1701 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1702   char * jcontentInfo = 0 ;
1703   void * jwindow  ;
1704
1705   if (!swig_callbackOnCreate) {
1706     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1707     return;
1708   } else {
1709     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1710     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1711     swig_callbackOnCreate(jcontentInfo, jwindow);
1712   }
1713 }
1714
1715 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1716   char * jcontentInfo = 0 ;
1717   int jtype  ;
1718
1719   if (!swig_callbackOnTerminate) {
1720     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1721     return;
1722   } else {
1723     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1724     jtype = (int)type;
1725     swig_callbackOnTerminate(jcontentInfo, jtype);
1726   }
1727 }
1728
1729 void SwigDirector_WidgetImpl::OnPause() {
1730   if (!swig_callbackOnPause) {
1731     Dali::Internal::Adaptor::Widget::OnPause();
1732     return;
1733   } else {
1734     swig_callbackOnPause();
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnResume() {
1739   if (!swig_callbackOnResume) {
1740     Dali::Internal::Adaptor::Widget::OnResume();
1741     return;
1742   } else {
1743     swig_callbackOnResume();
1744   }
1745 }
1746
1747 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1748   void * jwindow  ;
1749
1750   if (!swig_callbackOnResize) {
1751     Dali::Internal::Adaptor::Widget::OnResize(window);
1752     return;
1753   } else {
1754     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1755     swig_callbackOnResize(jwindow);
1756   }
1757 }
1758
1759 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1760   char * jcontentInfo = 0 ;
1761   int jforce  ;
1762
1763   if (!swig_callbackOnUpdate) {
1764     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1765     return;
1766   } else {
1767     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1768     jforce = force;
1769     swig_callbackOnUpdate(jcontentInfo, jforce);
1770   }
1771 }
1772
1773 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1774   void * jslotObserver = 0 ;
1775   void * jcallback = 0 ;
1776
1777   if (!swig_callbackSignalConnected) {
1778     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1779     return;
1780   } else {
1781     jslotObserver = (void *) slotObserver;
1782     jcallback = (void *) callback;
1783     swig_callbackSignalConnected(jslotObserver, jcallback);
1784   }
1785 }
1786
1787 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1788   void * jslotObserver = 0 ;
1789   void * jcallback = 0 ;
1790
1791   if (!swig_callbackSignalDisconnected) {
1792     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1793     return;
1794   } else {
1795     jslotObserver = (void *) slotObserver;
1796     jcallback = (void *) callback;
1797     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1798   }
1799 }
1800
1801 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) {
1802
1803   swig_callbackOnCreate = callbackOnCreate;
1804   swig_callbackOnTerminate = callbackOnTerminate;
1805   swig_callbackOnPause = callbackOnPause;
1806   swig_callbackOnResume = callbackOnResume;
1807   swig_callbackOnResize = callbackOnResize;
1808   swig_callbackOnUpdate = callbackOnUpdate;
1809   swig_callbackSignalConnected = callbackSignalConnected;
1810   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1811 }
1812
1813 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1814   swig_callbackOnCreate = 0;
1815   swig_callbackOnTerminate = 0;
1816   swig_callbackOnPause = 0;
1817   swig_callbackOnResume = 0;
1818   swig_callbackOnResize = 0;
1819   swig_callbackOnUpdate = 0;
1820   swig_callbackSignalConnected = 0;
1821   swig_callbackSignalDisconnected = 0;
1822 }
1823
1824
1825 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1826   swig_init_callbacks();
1827 }
1828
1829 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1830
1831 }
1832
1833
1834 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1835   int jdepth  ;
1836
1837   if (!swig_callbackOnStageConnection) {
1838     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1839     return;
1840   } else {
1841     jdepth = depth;
1842     swig_callbackOnStageConnection(jdepth);
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnStageDisconnection() {
1847   if (!swig_callbackOnStageDisconnection) {
1848     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1849     return;
1850   } else {
1851     swig_callbackOnStageDisconnection();
1852   }
1853 }
1854
1855 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1856   void * jchild = 0 ;
1857
1858   if (!swig_callbackOnChildAdd) {
1859     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1860     return;
1861   } else {
1862     jchild = (Dali::Actor *) &child;
1863     swig_callbackOnChildAdd(jchild);
1864   }
1865 }
1866
1867 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1868   void * jchild = 0 ;
1869
1870   if (!swig_callbackOnChildRemove) {
1871     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1872     return;
1873   } else {
1874     jchild = (Dali::Actor *) &child;
1875     swig_callbackOnChildRemove(jchild);
1876   }
1877 }
1878
1879 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1880   int jindex  ;
1881   void * jpropertyValue  ;
1882
1883   if (!swig_callbackOnPropertySet) {
1884     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1885     return;
1886   } else {
1887     jindex = index;
1888     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1889     swig_callbackOnPropertySet(jindex, jpropertyValue);
1890   }
1891 }
1892
1893 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1894   void * jtargetSize = 0 ;
1895
1896   if (!swig_callbackOnSizeSet) {
1897     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1898     return;
1899   } else {
1900     jtargetSize = (Dali::Vector3 *) &targetSize;
1901     swig_callbackOnSizeSet(jtargetSize);
1902   }
1903 }
1904
1905 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1906   void * janimation = 0 ;
1907   void * jtargetSize = 0 ;
1908
1909   if (!swig_callbackOnSizeAnimation) {
1910     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1911     return;
1912   } else {
1913     janimation = (Dali::Animation *) &animation;
1914     jtargetSize = (Dali::Vector3 *) &targetSize;
1915     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1916   }
1917 }
1918
1919 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1920   bool c_result = SwigValueInit< bool >() ;
1921   unsigned int jresult = 0 ;
1922   void * jarg0 = 0 ;
1923
1924   if (!swig_callbackOnTouchEvent) {
1925     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1926   } else {
1927     jarg0 = (Dali::TouchEvent *) &event;
1928     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1929     c_result = jresult ? true : false;
1930   }
1931   return c_result;
1932 }
1933
1934 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1935   bool c_result = SwigValueInit< bool >() ;
1936   unsigned int jresult = 0 ;
1937   void * jarg0 = 0 ;
1938
1939   if (!swig_callbackOnHoverEvent) {
1940     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1941   } else {
1942     jarg0 = (Dali::HoverEvent *) &event;
1943     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1944     c_result = jresult ? true : false;
1945   }
1946   return c_result;
1947 }
1948
1949 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1950   bool c_result = SwigValueInit< bool >() ;
1951   unsigned int jresult = 0 ;
1952   void * jarg0 = 0 ;
1953
1954   if (!swig_callbackOnKeyEvent) {
1955     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1956   } else {
1957     jarg0 = (Dali::KeyEvent *) &event;
1958     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1959     c_result = jresult ? true : false;
1960   }
1961   return c_result;
1962 }
1963
1964 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1965   bool c_result = SwigValueInit< bool >() ;
1966   unsigned int jresult = 0 ;
1967   void * jarg0 = 0 ;
1968
1969   if (!swig_callbackOnWheelEvent) {
1970     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1971   } else {
1972     jarg0 = (Dali::WheelEvent *) &event;
1973     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1974     c_result = jresult ? true : false;
1975   }
1976   return c_result;
1977 }
1978
1979 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1980   void * jsize = 0 ;
1981   void * jcontainer = 0 ;
1982
1983   if (!swig_callbackOnRelayout) {
1984     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1985     return;
1986   } else {
1987     jsize = (Dali::Vector2 *) &size;
1988     jcontainer = (Dali::RelayoutContainer *) &container;
1989     swig_callbackOnRelayout(jsize, jcontainer);
1990   }
1991 }
1992
1993 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1994   int jpolicy  ;
1995   int jdimension  ;
1996
1997   if (!swig_callbackOnSetResizePolicy) {
1998     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1999     return;
2000   } else {
2001     jpolicy = (int)policy;
2002     jdimension = (int)dimension;
2003     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2004   }
2005 }
2006
2007 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2008   Dali::Vector3 c_result ;
2009   void * jresult = 0 ;
2010
2011   if (!swig_callbackGetNaturalSize) {
2012     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2013   } else {
2014     jresult = (void *) swig_callbackGetNaturalSize();
2015     if (!jresult) {
2016       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2017       return c_result;
2018     }
2019     c_result = *(Dali::Vector3 *)jresult;
2020   }
2021   return c_result;
2022 }
2023
2024 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2025   float c_result = SwigValueInit< float >() ;
2026   float jresult = 0 ;
2027   void * jchild = 0 ;
2028   int jdimension  ;
2029
2030   if (!swig_callbackCalculateChildSize) {
2031     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2032   } else {
2033     jchild = (Dali::Actor *) &child;
2034     jdimension = (int)dimension;
2035     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2036     c_result = (float)jresult;
2037   }
2038   return c_result;
2039 }
2040
2041 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2042   float c_result = SwigValueInit< float >() ;
2043   float jresult = 0 ;
2044   float jwidth  ;
2045
2046   if (!swig_callbackGetHeightForWidth) {
2047     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2048   } else {
2049     jwidth = width;
2050     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2051     c_result = (float)jresult;
2052   }
2053   return c_result;
2054 }
2055
2056 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2057   float c_result = SwigValueInit< float >() ;
2058   float jresult = 0 ;
2059   float jheight  ;
2060
2061   if (!swig_callbackGetWidthForHeight) {
2062     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2063   } else {
2064     jheight = height;
2065     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2066     c_result = (float)jresult;
2067   }
2068   return c_result;
2069 }
2070
2071 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2072   bool c_result = SwigValueInit< bool >() ;
2073   unsigned int jresult = 0 ;
2074   int jdimension  ;
2075
2076   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2077     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2078   } else {
2079     jdimension = (int)dimension;
2080     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2081     c_result = jresult ? true : false;
2082   }
2083   return c_result;
2084 }
2085
2086 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2087   int jdimension  ;
2088
2089   if (!swig_callbackOnCalculateRelayoutSize) {
2090     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2091     return;
2092   } else {
2093     jdimension = (int)dimension;
2094     swig_callbackOnCalculateRelayoutSize(jdimension);
2095   }
2096 }
2097
2098 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2099   float jsize  ;
2100   int jdimension  ;
2101
2102   if (!swig_callbackOnLayoutNegotiated) {
2103     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2104     return;
2105   } else {
2106     jsize = size;
2107     jdimension = (int)dimension;
2108     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2109   }
2110 }
2111
2112 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2113   return Dali::CustomActorImpl::GetExtension();
2114 }
2115
2116 void SwigDirector_ViewImpl::OnInitialize() {
2117   if (!swig_callbackOnInitialize) {
2118     Dali::Toolkit::Internal::Control::OnInitialize();
2119     return;
2120   } else {
2121     swig_callbackOnInitialize();
2122   }
2123 }
2124
2125 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2126   void * jchild = 0 ;
2127
2128   if (!swig_callbackOnControlChildAdd) {
2129     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2130     return;
2131   } else {
2132     jchild = (Dali::Actor *) &child;
2133     swig_callbackOnControlChildAdd(jchild);
2134   }
2135 }
2136
2137 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2138   void * jchild = 0 ;
2139
2140   if (!swig_callbackOnControlChildRemove) {
2141     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2142     return;
2143   } else {
2144     jchild = (Dali::Actor *) &child;
2145     swig_callbackOnControlChildRemove(jchild);
2146   }
2147 }
2148
2149 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2150   void * jstyleManager  ;
2151   int jchange  ;
2152
2153   if (!swig_callbackOnStyleChange) {
2154     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2155     return;
2156   } else {
2157     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2158     jchange = (int)change;
2159     swig_callbackOnStyleChange(jstyleManager, jchange);
2160   }
2161 }
2162
2163 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2164   bool c_result = SwigValueInit< bool >() ;
2165   unsigned int jresult = 0 ;
2166
2167   if (!swig_callbackOnAccessibilityActivated) {
2168     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2169   } else {
2170     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2171     c_result = jresult ? true : false;
2172   }
2173   return c_result;
2174 }
2175
2176 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2177   bool c_result = SwigValueInit< bool >() ;
2178   unsigned int jresult = 0 ;
2179   void * jgesture  ;
2180
2181   if (!swig_callbackOnAccessibilityPan) {
2182     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2183   } else {
2184     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2185     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2186     c_result = jresult ? true : false;
2187   }
2188   return c_result;
2189 }
2190
2191 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2192   bool c_result = SwigValueInit< bool >() ;
2193   unsigned int jresult = 0 ;
2194   void * jtouchEvent = 0 ;
2195
2196   if (!swig_callbackOnAccessibilityTouch) {
2197     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2198   } else {
2199     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2200     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2201     c_result = jresult ? true : false;
2202   }
2203   return c_result;
2204 }
2205
2206 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2207   bool c_result = SwigValueInit< bool >() ;
2208   unsigned int jresult = 0 ;
2209   unsigned int jisIncrease  ;
2210
2211   if (!swig_callbackOnAccessibilityValueChange) {
2212     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2213   } else {
2214     jisIncrease = isIncrease;
2215     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2216     c_result = jresult ? true : false;
2217   }
2218   return c_result;
2219 }
2220
2221 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2222   bool c_result = SwigValueInit< bool >() ;
2223   unsigned int jresult = 0 ;
2224
2225   if (!swig_callbackOnAccessibilityZoom) {
2226     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2227   } else {
2228     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2229     c_result = jresult ? true : false;
2230   }
2231   return c_result;
2232 }
2233
2234 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2235   if (!swig_callbackOnKeyInputFocusGained) {
2236     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2237     return;
2238   } else {
2239     swig_callbackOnKeyInputFocusGained();
2240   }
2241 }
2242
2243 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2244   if (!swig_callbackOnKeyInputFocusLost) {
2245     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2246     return;
2247   } else {
2248     swig_callbackOnKeyInputFocusLost();
2249   }
2250 }
2251
2252 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2253   Dali::Actor c_result ;
2254   void * jresult = 0 ;
2255   void * jcurrentFocusedActor  ;
2256   int jdirection  ;
2257   unsigned int jloopEnabled  ;
2258
2259   if (!swig_callbackGetNextKeyboardFocusableActor) {
2260     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2261   } else {
2262     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2263     jdirection = (int)direction;
2264     jloopEnabled = loopEnabled;
2265     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2266     if (!jresult) {
2267       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2268       return c_result;
2269     }
2270     c_result = *(Dali::Actor *)jresult;
2271   }
2272   return c_result;
2273 }
2274
2275 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2276   void * jcommitedFocusableActor  ;
2277
2278   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2279     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2280     return;
2281   } else {
2282     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2283     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2284   }
2285 }
2286
2287 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2288   bool c_result = SwigValueInit< bool >() ;
2289   unsigned int jresult = 0 ;
2290
2291   if (!swig_callbackOnKeyboardEnter) {
2292     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2293   } else {
2294     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2295     c_result = jresult ? true : false;
2296   }
2297   return c_result;
2298 }
2299
2300 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2301   void * jpinch = 0 ;
2302
2303   if (!swig_callbackOnPinch) {
2304     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2305     return;
2306   } else {
2307     jpinch = (Dali::PinchGesture *) &pinch;
2308     swig_callbackOnPinch(jpinch);
2309   }
2310 }
2311
2312 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2313   void * jpan = 0 ;
2314
2315   if (!swig_callbackOnPan) {
2316     Dali::Toolkit::Internal::Control::OnPan(pan);
2317     return;
2318   } else {
2319     jpan = (Dali::PanGesture *) &pan;
2320     swig_callbackOnPan(jpan);
2321   }
2322 }
2323
2324 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2325   void * jtap = 0 ;
2326
2327   if (!swig_callbackOnTap) {
2328     Dali::Toolkit::Internal::Control::OnTap(tap);
2329     return;
2330   } else {
2331     jtap = (Dali::TapGesture *) &tap;
2332     swig_callbackOnTap(jtap);
2333   }
2334 }
2335
2336 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2337   void * jlongPress = 0 ;
2338
2339   if (!swig_callbackOnLongPress) {
2340     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2341     return;
2342   } else {
2343     jlongPress = (Dali::LongPressGesture *) &longPress;
2344     swig_callbackOnLongPress(jlongPress);
2345   }
2346 }
2347
2348 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2349   void * jslotObserver = 0 ;
2350   void * jcallback = 0 ;
2351
2352   if (!swig_callbackSignalConnected) {
2353     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2354     return;
2355   } else {
2356     jslotObserver = (void *) slotObserver;
2357     jcallback = (void *) callback;
2358     swig_callbackSignalConnected(jslotObserver, jcallback);
2359   }
2360 }
2361
2362 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2363   void * jslotObserver = 0 ;
2364   void * jcallback = 0 ;
2365
2366   if (!swig_callbackSignalDisconnected) {
2367     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2368     return;
2369   } else {
2370     jslotObserver = (void *) slotObserver;
2371     jcallback = (void *) callback;
2372     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2373   }
2374 }
2375
2376 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2377   return Dali::Toolkit::Internal::Control::GetControlExtension();
2378 }
2379
2380 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) {
2381   swig_callbackOnStageConnection = callbackOnStageConnection;
2382   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2383   swig_callbackOnChildAdd = callbackOnChildAdd;
2384   swig_callbackOnChildRemove = callbackOnChildRemove;
2385   swig_callbackOnPropertySet = callbackOnPropertySet;
2386   swig_callbackOnSizeSet = callbackOnSizeSet;
2387   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2388   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2389   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2390   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2391   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2392   swig_callbackOnRelayout = callbackOnRelayout;
2393   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2394   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2395   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2396   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2397   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2398   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2399   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2400   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2401   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2402   swig_callbackOnInitialize = callbackOnInitialize;
2403   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2404   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2405   swig_callbackOnStyleChange = callbackOnStyleChange;
2406   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2407   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2408   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2409   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2410   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2411   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2412   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2413   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2414   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2415   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2416   swig_callbackOnPinch = callbackOnPinch;
2417   swig_callbackOnPan = callbackOnPan;
2418   swig_callbackOnTap = callbackOnTap;
2419   swig_callbackOnLongPress = callbackOnLongPress;
2420   swig_callbackSignalConnected = callbackSignalConnected;
2421   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2422 }
2423
2424 void SwigDirector_ViewImpl::swig_init_callbacks() {
2425   swig_callbackOnStageConnection = 0;
2426   swig_callbackOnStageDisconnection = 0;
2427   swig_callbackOnChildAdd = 0;
2428   swig_callbackOnChildRemove = 0;
2429   swig_callbackOnPropertySet = 0;
2430   swig_callbackOnSizeSet = 0;
2431   swig_callbackOnSizeAnimation = 0;
2432   swig_callbackOnTouchEvent = 0;
2433   swig_callbackOnHoverEvent = 0;
2434   swig_callbackOnKeyEvent = 0;
2435   swig_callbackOnWheelEvent = 0;
2436   swig_callbackOnRelayout = 0;
2437   swig_callbackOnSetResizePolicy = 0;
2438   swig_callbackGetNaturalSize = 0;
2439   swig_callbackCalculateChildSize = 0;
2440   swig_callbackGetHeightForWidth = 0;
2441   swig_callbackGetWidthForHeight = 0;
2442   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2443   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2444   swig_callbackOnCalculateRelayoutSize = 0;
2445   swig_callbackOnLayoutNegotiated = 0;
2446   swig_callbackOnInitialize = 0;
2447   swig_callbackOnControlChildAdd = 0;
2448   swig_callbackOnControlChildRemove = 0;
2449   swig_callbackOnStyleChange = 0;
2450   swig_callbackOnAccessibilityActivated = 0;
2451   swig_callbackOnAccessibilityPan = 0;
2452   swig_callbackOnAccessibilityTouch = 0;
2453   swig_callbackOnAccessibilityValueChange = 0;
2454   swig_callbackOnAccessibilityZoom = 0;
2455   swig_callbackOnKeyInputFocusGained = 0;
2456   swig_callbackOnKeyInputFocusLost = 0;
2457   swig_callbackGetNextKeyboardFocusableActor = 0;
2458   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2459   swig_callbackOnKeyboardEnter = 0;
2460   swig_callbackOnPinch = 0;
2461   swig_callbackOnPan = 0;
2462   swig_callbackOnTap = 0;
2463   swig_callbackOnLongPress = 0;
2464   swig_callbackSignalConnected = 0;
2465   swig_callbackSignalDisconnected = 0;
2466 }
2467
2468 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2469   swig_init_callbacks();
2470 }
2471
2472 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2473
2474 }
2475
2476
2477 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2478   unsigned int c_result = SwigValueInit< unsigned int >() ;
2479   unsigned int jresult = 0 ;
2480
2481   if (!swig_callbackGetNumberOfItems) {
2482     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2483   } else {
2484     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2485     c_result = (unsigned int)jresult;
2486   }
2487   return c_result;
2488 }
2489
2490 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2491   Dali::Actor c_result ;
2492   void * jresult = 0 ;
2493   unsigned int jitemId  ;
2494
2495   if (!swig_callbackNewItem) {
2496     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2497   } else {
2498     jitemId = itemId;
2499     jresult = (void *) swig_callbackNewItem(jitemId);
2500     if (!jresult) {
2501       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2502       return c_result;
2503     }
2504     c_result = *(Dali::Actor *)jresult;
2505   }
2506   return c_result;
2507 }
2508
2509 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2510   unsigned int jitemId  ;
2511   void * jactor  ;
2512
2513   if (!swig_callbackItemReleased) {
2514     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2515     return;
2516   } else {
2517     jitemId = itemId;
2518     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2519     swig_callbackItemReleased(jitemId, jactor);
2520   }
2521 }
2522
2523 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2524   return Dali::Toolkit::ItemFactory::GetExtension();
2525 }
2526
2527 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2528   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2529   swig_callbackNewItem = callbackNewItem;
2530   swig_callbackItemReleased = callbackItemReleased;
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_init_callbacks() {
2534   swig_callbackGetNumberOfItems = 0;
2535   swig_callbackNewItem = 0;
2536   swig_callbackItemReleased = 0;
2537 }
2538
2539 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2540   swig_init_callbacks();
2541 }
2542
2543 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2544
2545 }
2546
2547
2548 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2549   Dali::Actor c_result ;
2550   void * jresult = 0 ;
2551   void * jcurrent  ;
2552   void * jproposed  ;
2553   int jdirection  ;
2554
2555   if (!swig_callbackGetNextFocusableActor) {
2556     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2557   } else {
2558     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2559     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2560     jdirection = (int)direction;
2561     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2562     if (!jresult) {
2563       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2564       return c_result;
2565     }
2566     c_result = *(Dali::Actor *)jresult;
2567   }
2568   return c_result;
2569 }
2570
2571 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2572   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2573 }
2574
2575 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2576   swig_callbackGetNextFocusableActor = 0;
2577 }
2578
2579
2580 #ifdef __cplusplus
2581 extern "C" {
2582 #endif
2583
2584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2585   void * jresult ;
2586   floatp *result = 0 ;
2587
2588   {
2589     try {
2590       result = (floatp *)new_floatp();
2591     } catch (std::out_of_range& e) {
2592       {
2593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2594       };
2595     } catch (std::exception& e) {
2596       {
2597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2598       };
2599     } catch (DaliException e) {
2600       {
2601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2602       };
2603     } catch (...) {
2604       {
2605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2606       };
2607     }
2608   }
2609   jresult = (void *)result;
2610   return jresult;
2611 }
2612
2613
2614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2615   floatp *arg1 = (floatp *) 0 ;
2616
2617   arg1 = (floatp *)jarg1;
2618   {
2619     try {
2620       delete_floatp(arg1);
2621     } catch (std::out_of_range& e) {
2622       {
2623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2624       };
2625     } catch (std::exception& e) {
2626       {
2627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2628       };
2629     } catch (Dali::DaliException e) {
2630       {
2631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2632       };
2633     } catch (...) {
2634       {
2635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2636       };
2637     }
2638   }
2639
2640 }
2641
2642
2643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2644   floatp *arg1 = (floatp *) 0 ;
2645   float arg2 ;
2646
2647   arg1 = (floatp *)jarg1;
2648   arg2 = (float)jarg2;
2649   {
2650     try {
2651       floatp_assign(arg1,arg2);
2652     } catch (std::out_of_range& e) {
2653       {
2654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2655       };
2656     } catch (std::exception& e) {
2657       {
2658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (Dali::DaliException e) {
2661       {
2662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2663       };
2664     } catch (...) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2667       };
2668     }
2669   }
2670
2671 }
2672
2673
2674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2675   float jresult ;
2676   floatp *arg1 = (floatp *) 0 ;
2677   float result;
2678
2679   arg1 = (floatp *)jarg1;
2680   {
2681     try {
2682       result = (float)floatp_value(arg1);
2683     } catch (std::out_of_range& e) {
2684       {
2685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2686       };
2687     } catch (std::exception& e) {
2688       {
2689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2690       };
2691     } catch (DaliException e) {
2692       {
2693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2694       };
2695     } catch (...) {
2696       {
2697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2698       };
2699     }
2700   }
2701   jresult = result;
2702   return jresult;
2703 }
2704
2705
2706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2707   void * jresult ;
2708   floatp *arg1 = (floatp *) 0 ;
2709   float *result = 0 ;
2710
2711   arg1 = (floatp *)jarg1;
2712   {
2713     try {
2714       result = (float *)floatp_cast(arg1);
2715     } catch (std::out_of_range& e) {
2716       {
2717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2718       };
2719     } catch (std::exception& e) {
2720       {
2721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2722       };
2723     } catch (Dali::DaliException e) {
2724       {
2725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2726       };
2727     } catch (...) {
2728       {
2729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2730       };
2731     }
2732   }
2733
2734   jresult = (void *)result;
2735   return jresult;
2736 }
2737
2738
2739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2740   void * jresult ;
2741   float *arg1 = (float *) 0 ;
2742   floatp *result = 0 ;
2743
2744   arg1 = (float *)jarg1;
2745   {
2746     try {
2747       result = (floatp *)floatp_frompointer(arg1);
2748     } catch (std::out_of_range& e) {
2749       {
2750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2751       };
2752     } catch (std::exception& e) {
2753       {
2754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2755       };
2756     } catch (Dali::DaliException e) {
2757       {
2758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2759       };
2760     } catch (...) {
2761       {
2762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2763       };
2764     }
2765   }
2766
2767   jresult = (void *)result;
2768   return jresult;
2769 }
2770
2771
2772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2773   void * jresult ;
2774   intp *result = 0 ;
2775
2776   {
2777     try {
2778       result = (intp *)new_intp();
2779     } catch (std::out_of_range& e) {
2780       {
2781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2782       };
2783     } catch (std::exception& e) {
2784       {
2785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2786       };
2787     } catch (Dali::DaliException e) {
2788       {
2789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2790       };
2791     } catch (...) {
2792       {
2793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2794       };
2795     }
2796   }
2797
2798   jresult = (void *)result;
2799   return jresult;
2800 }
2801
2802
2803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2804   intp *arg1 = (intp *) 0 ;
2805
2806   arg1 = (intp *)jarg1;
2807   {
2808     try {
2809       delete_intp(arg1);
2810     } catch (std::out_of_range& e) {
2811       {
2812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2813       };
2814     } catch (std::exception& e) {
2815       {
2816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2817       };
2818     } catch (Dali::DaliException e) {
2819       {
2820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2821       };
2822     } catch (...) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2825       };
2826     }
2827   }
2828
2829 }
2830
2831
2832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2833   intp *arg1 = (intp *) 0 ;
2834   int arg2 ;
2835
2836   arg1 = (intp *)jarg1;
2837   arg2 = (int)jarg2;
2838   {
2839     try {
2840       intp_assign(arg1,arg2);
2841     } catch (std::out_of_range& e) {
2842       {
2843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2844       };
2845     } catch (std::exception& e) {
2846       {
2847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2848       };
2849     } catch (Dali::DaliException e) {
2850       {
2851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2852       };
2853     } catch (...) {
2854       {
2855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2856       };
2857     }
2858   }
2859
2860 }
2861
2862
2863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2864   int jresult ;
2865   intp *arg1 = (intp *) 0 ;
2866   int result;
2867
2868   arg1 = (intp *)jarg1;
2869   {
2870     try {
2871       result = (int)intp_value(arg1);
2872     } catch (std::out_of_range& e) {
2873       {
2874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2875       };
2876     } catch (std::exception& e) {
2877       {
2878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2879       };
2880     } catch (Dali::DaliException e) {
2881       {
2882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2883       };
2884     } catch (...) {
2885       {
2886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2887       };
2888     }
2889   }
2890
2891   jresult = result;
2892   return jresult;
2893 }
2894
2895
2896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2897   void * jresult ;
2898   intp *arg1 = (intp *) 0 ;
2899   int *result = 0 ;
2900
2901   arg1 = (intp *)jarg1;
2902   {
2903     try {
2904       result = (int *)intp_cast(arg1);
2905     } catch (std::out_of_range& e) {
2906       {
2907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2908       };
2909     } catch (std::exception& e) {
2910       {
2911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2912       };
2913     } catch (Dali::DaliException e) {
2914       {
2915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2916       };
2917     } catch (...) {
2918       {
2919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2920       };
2921     }
2922   }
2923
2924   jresult = (void *)result;
2925   return jresult;
2926 }
2927
2928
2929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2930   void * jresult ;
2931   int *arg1 = (int *) 0 ;
2932   intp *result = 0 ;
2933
2934   arg1 = (int *)jarg1;
2935   {
2936     try {
2937       result = (intp *)intp_frompointer(arg1);
2938     } catch (std::out_of_range& e) {
2939       {
2940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2941       };
2942     } catch (std::exception& e) {
2943       {
2944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2945       };
2946     } catch (Dali::DaliException e) {
2947       {
2948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2949       };
2950     } catch (...) {
2951       {
2952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2953       };
2954     }
2955   }
2956
2957   jresult = (void *)result;
2958   return jresult;
2959 }
2960
2961
2962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2963   void * jresult ;
2964   doublep *result = 0 ;
2965
2966   {
2967     try {
2968       result = (doublep *)new_doublep();
2969     } catch (std::out_of_range& e) {
2970       {
2971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2972       };
2973     } catch (std::exception& e) {
2974       {
2975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2976       };
2977     } catch (Dali::DaliException e) {
2978       {
2979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2980       };
2981     } catch (...) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2984       };
2985     }
2986   }
2987
2988   jresult = (void *)result;
2989   return jresult;
2990 }
2991
2992
2993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2994   doublep *arg1 = (doublep *) 0 ;
2995
2996   arg1 = (doublep *)jarg1;
2997   {
2998     try {
2999       delete_doublep(arg1);
3000     } catch (std::out_of_range& e) {
3001       {
3002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3003       };
3004     } catch (std::exception& e) {
3005       {
3006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3007       };
3008     } catch (Dali::DaliException e) {
3009       {
3010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3011       };
3012     } catch (...) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3015       };
3016     }
3017   }
3018
3019 }
3020
3021
3022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3023   doublep *arg1 = (doublep *) 0 ;
3024   double arg2 ;
3025
3026   arg1 = (doublep *)jarg1;
3027   arg2 = (double)jarg2;
3028   {
3029     try {
3030       doublep_assign(arg1,arg2);
3031     } catch (std::out_of_range& e) {
3032       {
3033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3034       };
3035     } catch (std::exception& e) {
3036       {
3037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3038       };
3039     } catch (Dali::DaliException e) {
3040       {
3041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3042       };
3043     } catch (...) {
3044       {
3045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3046       };
3047     }
3048   }
3049
3050 }
3051
3052
3053 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3054   double jresult ;
3055   doublep *arg1 = (doublep *) 0 ;
3056   double result;
3057
3058   arg1 = (doublep *)jarg1;
3059   {
3060     try {
3061       result = (double)doublep_value(arg1);
3062     } catch (std::out_of_range& e) {
3063       {
3064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3065       };
3066     } catch (std::exception& e) {
3067       {
3068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3069       };
3070     } catch (Dali::DaliException e) {
3071       {
3072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3073       };
3074     } catch (...) {
3075       {
3076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3077       };
3078     }
3079   }
3080
3081   jresult = result;
3082   return jresult;
3083 }
3084
3085
3086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3087   void * jresult ;
3088   doublep *arg1 = (doublep *) 0 ;
3089   double *result = 0 ;
3090
3091   arg1 = (doublep *)jarg1;
3092   {
3093     try {
3094       result = (double *)doublep_cast(arg1);
3095     } catch (std::out_of_range& e) {
3096       {
3097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3098       };
3099     } catch (std::exception& e) {
3100       {
3101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3102       };
3103     } catch (Dali::DaliException e) {
3104       {
3105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3106       };
3107     } catch (...) {
3108       {
3109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3110       };
3111     }
3112   }
3113
3114   jresult = (void *)result;
3115   return jresult;
3116 }
3117
3118
3119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3120   void * jresult ;
3121   double *arg1 = (double *) 0 ;
3122   doublep *result = 0 ;
3123
3124   arg1 = (double *)jarg1;
3125   {
3126     try {
3127       result = (doublep *)doublep_frompointer(arg1);
3128     } catch (std::out_of_range& e) {
3129       {
3130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3131       };
3132     } catch (std::exception& e) {
3133       {
3134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3135       };
3136     } catch (Dali::DaliException e) {
3137       {
3138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3139       };
3140     } catch (...) {
3141       {
3142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3143       };
3144     }
3145   }
3146
3147   jresult = (void *)result;
3148   return jresult;
3149 }
3150
3151
3152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3153   void * jresult ;
3154   uintp *result = 0 ;
3155
3156   {
3157     try {
3158       result = (uintp *)new_uintp();
3159     } catch (std::out_of_range& e) {
3160       {
3161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3162       };
3163     } catch (std::exception& e) {
3164       {
3165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3166       };
3167     } catch (Dali::DaliException e) {
3168       {
3169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3170       };
3171     } catch (...) {
3172       {
3173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3174       };
3175     }
3176   }
3177
3178   jresult = (void *)result;
3179   return jresult;
3180 }
3181
3182
3183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3184   uintp *arg1 = (uintp *) 0 ;
3185
3186   arg1 = (uintp *)jarg1;
3187   {
3188     try {
3189       delete_uintp(arg1);
3190     } catch (std::out_of_range& e) {
3191       {
3192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3193       };
3194     } catch (std::exception& e) {
3195       {
3196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3197       };
3198     } catch (Dali::DaliException e) {
3199       {
3200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3201       };
3202     } catch (...) {
3203       {
3204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3205       };
3206     }
3207   }
3208
3209 }
3210
3211
3212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3213   uintp *arg1 = (uintp *) 0 ;
3214   unsigned int arg2 ;
3215
3216   arg1 = (uintp *)jarg1;
3217   arg2 = (unsigned int)jarg2;
3218   {
3219     try {
3220       uintp_assign(arg1,arg2);
3221     } catch (std::out_of_range& e) {
3222       {
3223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3224       };
3225     } catch (std::exception& e) {
3226       {
3227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3228       };
3229     } catch (Dali::DaliException e) {
3230       {
3231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3232       };
3233     } catch (...) {
3234       {
3235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3236       };
3237     }
3238   }
3239
3240 }
3241
3242
3243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3244   unsigned int jresult ;
3245   uintp *arg1 = (uintp *) 0 ;
3246   unsigned int result;
3247
3248   arg1 = (uintp *)jarg1;
3249   {
3250     try {
3251       result = (unsigned int)uintp_value(arg1);
3252     } catch (std::out_of_range& e) {
3253       {
3254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3255       };
3256     } catch (std::exception& e) {
3257       {
3258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3259       };
3260     } catch (Dali::DaliException e) {
3261       {
3262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3263       };
3264     } catch (...) {
3265       {
3266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3267       };
3268     }
3269   }
3270
3271   jresult = result;
3272   return jresult;
3273 }
3274
3275
3276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3277   void * jresult ;
3278   uintp *arg1 = (uintp *) 0 ;
3279   unsigned int *result = 0 ;
3280
3281   arg1 = (uintp *)jarg1;
3282   {
3283     try {
3284       result = (unsigned int *)uintp_cast(arg1);
3285     } catch (std::out_of_range& e) {
3286       {
3287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3288       };
3289     } catch (std::exception& e) {
3290       {
3291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (Dali::DaliException e) {
3294       {
3295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3296       };
3297     } catch (...) {
3298       {
3299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3300       };
3301     }
3302   }
3303
3304   jresult = (void *)result;
3305   return jresult;
3306 }
3307
3308
3309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3310   void * jresult ;
3311   unsigned int *arg1 = (unsigned int *) 0 ;
3312   uintp *result = 0 ;
3313
3314   arg1 = (unsigned int *)jarg1;
3315   {
3316     try {
3317       result = (uintp *)uintp_frompointer(arg1);
3318     } catch (std::out_of_range& e) {
3319       {
3320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3321       };
3322     } catch (std::exception& e) {
3323       {
3324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3325       };
3326     } catch (Dali::DaliException e) {
3327       {
3328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3329       };
3330     } catch (...) {
3331       {
3332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3333       };
3334     }
3335   }
3336
3337   jresult = (void *)result;
3338   return jresult;
3339 }
3340
3341
3342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3343   void * jresult ;
3344   ushortp *result = 0 ;
3345
3346   {
3347     try {
3348       result = (ushortp *)new_ushortp();
3349     } catch (std::out_of_range& e) {
3350       {
3351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3352       };
3353     } catch (std::exception& e) {
3354       {
3355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3356       };
3357     } catch (Dali::DaliException e) {
3358       {
3359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3360       };
3361     } catch (...) {
3362       {
3363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3364       };
3365     }
3366   }
3367
3368   jresult = (void *)result;
3369   return jresult;
3370 }
3371
3372
3373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3374   ushortp *arg1 = (ushortp *) 0 ;
3375
3376   arg1 = (ushortp *)jarg1;
3377   {
3378     try {
3379       delete_ushortp(arg1);
3380     } catch (std::out_of_range& e) {
3381       {
3382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3383       };
3384     } catch (std::exception& e) {
3385       {
3386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3387       };
3388     } catch (Dali::DaliException e) {
3389       {
3390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3391       };
3392     } catch (...) {
3393       {
3394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3395       };
3396     }
3397   }
3398
3399 }
3400
3401
3402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3403   ushortp *arg1 = (ushortp *) 0 ;
3404   unsigned short arg2 ;
3405
3406   arg1 = (ushortp *)jarg1;
3407   arg2 = (unsigned short)jarg2;
3408   {
3409     try {
3410       ushortp_assign(arg1,arg2);
3411     } catch (std::out_of_range& e) {
3412       {
3413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3414       };
3415     } catch (std::exception& e) {
3416       {
3417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3418       };
3419     } catch (Dali::DaliException e) {
3420       {
3421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3422       };
3423     } catch (...) {
3424       {
3425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3426       };
3427     }
3428   }
3429
3430 }
3431
3432
3433 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3434   unsigned short jresult ;
3435   ushortp *arg1 = (ushortp *) 0 ;
3436   unsigned short result;
3437
3438   arg1 = (ushortp *)jarg1;
3439   {
3440     try {
3441       result = (unsigned short)ushortp_value(arg1);
3442     } catch (std::out_of_range& e) {
3443       {
3444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3445       };
3446     } catch (std::exception& e) {
3447       {
3448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3449       };
3450     } catch (Dali::DaliException e) {
3451       {
3452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3453       };
3454     } catch (...) {
3455       {
3456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3457       };
3458     }
3459   }
3460
3461   jresult = result;
3462   return jresult;
3463 }
3464
3465
3466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3467   void * jresult ;
3468   ushortp *arg1 = (ushortp *) 0 ;
3469   unsigned short *result = 0 ;
3470
3471   arg1 = (ushortp *)jarg1;
3472   {
3473     try {
3474       result = (unsigned short *)ushortp_cast(arg1);
3475     } catch (std::out_of_range& e) {
3476       {
3477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3478       };
3479     } catch (std::exception& e) {
3480       {
3481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3482       };
3483     } catch (Dali::DaliException e) {
3484       {
3485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3486       };
3487     } catch (...) {
3488       {
3489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3490       };
3491     }
3492   }
3493
3494   jresult = (void *)result;
3495   return jresult;
3496 }
3497
3498
3499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3500   void * jresult ;
3501   unsigned short *arg1 = (unsigned short *) 0 ;
3502   ushortp *result = 0 ;
3503
3504   arg1 = (unsigned short *)jarg1;
3505   {
3506     try {
3507       result = (ushortp *)ushortp_frompointer(arg1);
3508     } catch (std::out_of_range& e) {
3509       {
3510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3511       };
3512     } catch (std::exception& e) {
3513       {
3514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (Dali::DaliException e) {
3517       {
3518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3519       };
3520     } catch (...) {
3521       {
3522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3523       };
3524     }
3525   }
3526
3527   jresult = (void *)result;
3528   return jresult;
3529 }
3530
3531
3532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3533   unsigned int jresult ;
3534   int arg1 ;
3535   unsigned int result;
3536
3537   arg1 = (int)jarg1;
3538   {
3539     try {
3540       result = (unsigned int)int_to_uint(arg1);
3541     } catch (std::out_of_range& e) {
3542       {
3543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3544       };
3545     } catch (std::exception& e) {
3546       {
3547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (Dali::DaliException e) {
3550       {
3551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3552       };
3553     } catch (...) {
3554       {
3555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3556       };
3557     }
3558   }
3559
3560   jresult = result;
3561   return jresult;
3562 }
3563
3564
3565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3566   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3567
3568   arg1 = (Dali::RefObject *)jarg1;
3569   {
3570     try {
3571       (arg1)->Reference();
3572     } catch (std::out_of_range& e) {
3573       {
3574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3575       };
3576     } catch (std::exception& e) {
3577       {
3578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (Dali::DaliException e) {
3581       {
3582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3583       };
3584     } catch (...) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3587       };
3588     }
3589   }
3590
3591 }
3592
3593
3594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3595   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3596
3597   arg1 = (Dali::RefObject *)jarg1;
3598   {
3599     try {
3600       (arg1)->Unreference();
3601     } catch (std::out_of_range& e) {
3602       {
3603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3604       };
3605     } catch (std::exception& e) {
3606       {
3607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3608       };
3609     } catch (Dali::DaliException e) {
3610       {
3611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3612       };
3613     } catch (...) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3616       };
3617     }
3618   }
3619
3620 }
3621
3622
3623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3624   int jresult ;
3625   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3626   int result;
3627
3628   arg1 = (Dali::RefObject *)jarg1;
3629   {
3630     try {
3631       result = (int)(arg1)->ReferenceCount();
3632     } catch (std::out_of_range& e) {
3633       {
3634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3635       };
3636     } catch (std::exception& e) {
3637       {
3638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3639       };
3640     } catch (Dali::DaliException e) {
3641       {
3642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3643       };
3644     } catch (...) {
3645       {
3646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3647       };
3648     }
3649   }
3650
3651   jresult = result;
3652   return jresult;
3653 }
3654
3655
3656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3657   void * jresult ;
3658   Dali::Any *result = 0 ;
3659
3660   {
3661     try {
3662       result = (Dali::Any *)new Dali::Any();
3663     } catch (std::out_of_range& e) {
3664       {
3665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3666       };
3667     } catch (std::exception& e) {
3668       {
3669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3670       };
3671     } catch (Dali::DaliException e) {
3672       {
3673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3674       };
3675     } catch (...) {
3676       {
3677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3678       };
3679     }
3680   }
3681
3682   jresult = (void *)result;
3683   return jresult;
3684 }
3685
3686
3687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3688   Dali::Any *arg1 = (Dali::Any *) 0 ;
3689
3690   arg1 = (Dali::Any *)jarg1;
3691   {
3692     try {
3693       delete arg1;
3694     } catch (std::out_of_range& e) {
3695       {
3696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3697       };
3698     } catch (std::exception& e) {
3699       {
3700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3701       };
3702     } catch (Dali::DaliException e) {
3703       {
3704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3705       };
3706     } catch (...) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3709       };
3710     }
3711   }
3712
3713 }
3714
3715
3716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3717   char *arg1 = (char *) 0 ;
3718
3719   arg1 = (char *)jarg1;
3720   {
3721     try {
3722       Dali::Any::AssertAlways((char const *)arg1);
3723     } catch (std::out_of_range& e) {
3724       {
3725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3726       };
3727     } catch (std::exception& e) {
3728       {
3729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3730       };
3731     } catch (Dali::DaliException e) {
3732       {
3733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3734       };
3735     } catch (...) {
3736       {
3737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3738       };
3739     }
3740   }
3741
3742 }
3743
3744
3745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3746   void * jresult ;
3747   Dali::Any *arg1 = 0 ;
3748   Dali::Any *result = 0 ;
3749
3750   arg1 = (Dali::Any *)jarg1;
3751   if (!arg1) {
3752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3753     return 0;
3754   }
3755   {
3756     try {
3757       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3758     } catch (std::out_of_range& e) {
3759       {
3760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3761       };
3762     } catch (std::exception& e) {
3763       {
3764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (Dali::DaliException e) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3769       };
3770     } catch (...) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3773       };
3774     }
3775   }
3776
3777   jresult = (void *)result;
3778   return jresult;
3779 }
3780
3781
3782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3783   void * jresult ;
3784   Dali::Any *arg1 = (Dali::Any *) 0 ;
3785   Dali::Any *arg2 = 0 ;
3786   Dali::Any *result = 0 ;
3787
3788   arg1 = (Dali::Any *)jarg1;
3789   arg2 = (Dali::Any *)jarg2;
3790   if (!arg2) {
3791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3792     return 0;
3793   }
3794   {
3795     try {
3796       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3797     } catch (std::out_of_range& e) {
3798       {
3799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3800       };
3801     } catch (std::exception& e) {
3802       {
3803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3804       };
3805     } catch (Dali::DaliException e) {
3806       {
3807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3808       };
3809     } catch (...) {
3810       {
3811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3812       };
3813     }
3814   }
3815
3816   jresult = (void *)result;
3817   return jresult;
3818 }
3819
3820
3821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3822   void * jresult ;
3823   Dali::Any *arg1 = (Dali::Any *) 0 ;
3824   std::type_info *result = 0 ;
3825
3826   arg1 = (Dali::Any *)jarg1;
3827   {
3828     try {
3829       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3830     } catch (std::out_of_range& e) {
3831       {
3832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3833       };
3834     } catch (std::exception& e) {
3835       {
3836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3837       };
3838     } catch (Dali::DaliException e) {
3839       {
3840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3841       };
3842     } catch (...) {
3843       {
3844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3845       };
3846     }
3847   }
3848
3849   jresult = (void *)result;
3850   return jresult;
3851 }
3852
3853
3854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3855   unsigned int jresult ;
3856   Dali::Any *arg1 = (Dali::Any *) 0 ;
3857   bool result;
3858
3859   arg1 = (Dali::Any *)jarg1;
3860   {
3861     try {
3862       result = (bool)((Dali::Any const *)arg1)->Empty();
3863     } catch (std::out_of_range& e) {
3864       {
3865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3866       };
3867     } catch (std::exception& e) {
3868       {
3869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3870       };
3871     } catch (Dali::DaliException e) {
3872       {
3873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3874       };
3875     } catch (...) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3878       };
3879     }
3880   }
3881
3882   jresult = result;
3883   return jresult;
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3888   void * jresult ;
3889   std::type_info *arg1 = 0 ;
3890   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3891   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3892   Dali::Any::AnyContainerBase *result = 0 ;
3893
3894   arg1 = (std::type_info *)jarg1;
3895   if (!arg1) {
3896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3897     return 0;
3898   }
3899   arg2 = (Dali::Any::CloneFunc)jarg2;
3900   arg3 = (Dali::Any::DeleteFunc)jarg3;
3901   {
3902     try {
3903       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3904     } catch (std::out_of_range& e) {
3905       {
3906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3907       };
3908     } catch (std::exception& e) {
3909       {
3910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (Dali::DaliException e) {
3913       {
3914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3915       };
3916     } catch (...) {
3917       {
3918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3919       };
3920     }
3921   }
3922
3923   jresult = (void *)result;
3924   return jresult;
3925 }
3926
3927
3928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3929   void * jresult ;
3930   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3931   std::type_info *result = 0 ;
3932
3933   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3934   {
3935     try {
3936       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3937     } catch (std::out_of_range& e) {
3938       {
3939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3940       };
3941     } catch (std::exception& e) {
3942       {
3943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3944       };
3945     } catch (Dali::DaliException e) {
3946       {
3947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3948       };
3949     } catch (...) {
3950       {
3951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3952       };
3953     }
3954   }
3955
3956   jresult = (void *)result;
3957   return jresult;
3958 }
3959
3960
3961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3962   void * jresult ;
3963   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3964   ::std::type_info *result = 0 ;
3965
3966   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3967   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3968   jresult = (void *)result;
3969   return jresult;
3970 }
3971
3972
3973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3974   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3975   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3976
3977   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3978   arg2 = (Dali::Any::CloneFunc)jarg2;
3979   if (arg1) (arg1)->mCloneFunc = arg2;
3980 }
3981
3982
3983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3984   void * jresult ;
3985   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3986   Dali::Any::CloneFunc result;
3987
3988   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3989   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3990   jresult = (void *)result;
3991   return jresult;
3992 }
3993
3994
3995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3996   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3997   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3998
3999   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4000   arg2 = (Dali::Any::DeleteFunc)jarg2;
4001   if (arg1) (arg1)->mDeleteFunc = arg2;
4002 }
4003
4004
4005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4006   void * jresult ;
4007   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4008   Dali::Any::DeleteFunc result;
4009
4010   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4011   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4012   jresult = (void *)result;
4013   return jresult;
4014 }
4015
4016
4017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4018   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4019
4020   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4021   {
4022     try {
4023       delete arg1;
4024     } catch (std::out_of_range& e) {
4025       {
4026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4027       };
4028     } catch (std::exception& e) {
4029       {
4030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4031       };
4032     } catch (Dali::DaliException e) {
4033       {
4034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4035       };
4036     } catch (...) {
4037       {
4038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4039       };
4040     }
4041   }
4042
4043 }
4044
4045
4046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4047   Dali::Any *arg1 = (Dali::Any *) 0 ;
4048   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4049
4050   arg1 = (Dali::Any *)jarg1;
4051   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4052   if (arg1) (arg1)->mContainer = arg2;
4053 }
4054
4055
4056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4057   void * jresult ;
4058   Dali::Any *arg1 = (Dali::Any *) 0 ;
4059   Dali::Any::AnyContainerBase *result = 0 ;
4060
4061   arg1 = (Dali::Any *)jarg1;
4062   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4063   jresult = (void *)result;
4064   return jresult;
4065 }
4066
4067
4068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4069   char *arg1 = (char *) 0 ;
4070   char *arg2 = (char *) 0 ;
4071
4072   arg1 = (char *)jarg1;
4073   arg2 = (char *)jarg2;
4074   {
4075     try {
4076       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4077     } catch (std::out_of_range& e) {
4078       {
4079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4080       };
4081     } catch (std::exception& e) {
4082       {
4083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4084       };
4085     } catch (Dali::DaliException e) {
4086       {
4087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4088       };
4089     } catch (...) {
4090       {
4091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4092       };
4093     }
4094   }
4095
4096 }
4097
4098
4099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4100   void * jresult ;
4101   char *arg1 = (char *) 0 ;
4102   char *arg2 = (char *) 0 ;
4103   Dali::DaliException *result = 0 ;
4104
4105   arg1 = (char *)jarg1;
4106   arg2 = (char *)jarg2;
4107   {
4108     try {
4109       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4110     } catch (std::out_of_range& e) {
4111       {
4112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4113       };
4114     } catch (std::exception& e) {
4115       {
4116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4117       };
4118     } catch (Dali::DaliException e) {
4119       {
4120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4121       };
4122     } catch (...) {
4123       {
4124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4125       };
4126     }
4127   }
4128
4129   jresult = (void *)result;
4130   return jresult;
4131 }
4132
4133
4134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4135   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4136   std::string arg2 = std::string(jarg2);
4137
4138   arg1 = (Dali::DaliException *)jarg1;
4139   {
4140     if (!arg2.empty()) {
4141       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4142     } else {
4143       arg1->location = 0;
4144     }
4145   }
4146 }
4147
4148 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4149   char * jresult ;
4150   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4151   char *result = 0 ;
4152
4153   arg1 = (Dali::DaliException *)jarg1;
4154   result = (char *) ((arg1)->location);
4155   jresult = SWIG_csharp_string_callback((const char *)result);
4156   return jresult;
4157 }
4158
4159
4160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4161   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4162   std::string arg2 = std::string(jarg2);
4163
4164   arg1 = (Dali::DaliException *)jarg1;
4165   {
4166     if (!arg2.empty()) {
4167       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4168     } else {
4169       arg1->condition = 0;
4170     }
4171   }
4172 }
4173
4174
4175 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4176   char * jresult ;
4177   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4178   char *result = 0 ;
4179
4180   arg1 = (Dali::DaliException *)jarg1;
4181   result = (char *) ((arg1)->condition);
4182   jresult = SWIG_csharp_string_callback((const char *)result);
4183   return jresult;
4184 }
4185
4186
4187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4188   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4189
4190   arg1 = (Dali::DaliException *)jarg1;
4191   {
4192     try {
4193       delete arg1;
4194     } catch (std::out_of_range& e) {
4195       {
4196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4197       };
4198     } catch (std::exception& e) {
4199       {
4200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4201       };
4202     } catch (Dali::DaliException e) {
4203       {
4204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4205       };
4206     } catch (...) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4209       };
4210     }
4211   }
4212
4213 }
4214
4215
4216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4217   void * jresult ;
4218   Dali::Vector2 *result = 0 ;
4219
4220   {
4221     try {
4222       result = (Dali::Vector2 *)new Dali::Vector2();
4223     } catch (std::out_of_range& e) {
4224       {
4225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4226       };
4227     } catch (std::exception& e) {
4228       {
4229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4230       };
4231     } catch (Dali::DaliException e) {
4232       {
4233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4234       };
4235     } catch (...) {
4236       {
4237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4238       };
4239     }
4240   }
4241
4242   jresult = (void *)result;
4243   return jresult;
4244 }
4245
4246
4247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4248   void * jresult ;
4249   float arg1 ;
4250   float arg2 ;
4251   Dali::Vector2 *result = 0 ;
4252
4253   arg1 = (float)jarg1;
4254   arg2 = (float)jarg2;
4255   {
4256     try {
4257       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4258     } catch (std::out_of_range& e) {
4259       {
4260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4261       };
4262     } catch (std::exception& e) {
4263       {
4264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4265       };
4266     } catch (Dali::DaliException e) {
4267       {
4268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4269       };
4270     } catch (...) {
4271       {
4272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4273       };
4274     }
4275   }
4276
4277   jresult = (void *)result;
4278   return jresult;
4279 }
4280
4281
4282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4283   void * jresult ;
4284   float *arg1 = (float *) 0 ;
4285   Dali::Vector2 *result = 0 ;
4286
4287   arg1 = jarg1;
4288   {
4289     try {
4290       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4291     } catch (std::out_of_range& e) {
4292       {
4293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (std::exception& e) {
4296       {
4297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (Dali::DaliException e) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4302       };
4303     } catch (...) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4306       };
4307     }
4308   }
4309
4310   jresult = (void *)result;
4311
4312
4313   return jresult;
4314 }
4315
4316
4317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4318   void * jresult ;
4319   Dali::Vector3 *arg1 = 0 ;
4320   Dali::Vector2 *result = 0 ;
4321
4322   arg1 = (Dali::Vector3 *)jarg1;
4323   if (!arg1) {
4324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4325     return 0;
4326   }
4327   {
4328     try {
4329       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4330     } catch (std::out_of_range& e) {
4331       {
4332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (std::exception& e) {
4335       {
4336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4337       };
4338     } catch (Dali::DaliException e) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4341       };
4342     } catch (...) {
4343       {
4344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4345       };
4346     }
4347   }
4348
4349   jresult = (void *)result;
4350   return jresult;
4351 }
4352
4353
4354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4355   void * jresult ;
4356   Dali::Vector4 *arg1 = 0 ;
4357   Dali::Vector2 *result = 0 ;
4358
4359   arg1 = (Dali::Vector4 *)jarg1;
4360   if (!arg1) {
4361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4362     return 0;
4363   }
4364   {
4365     try {
4366       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4367     } catch (std::out_of_range& e) {
4368       {
4369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4370       };
4371     } catch (std::exception& e) {
4372       {
4373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4374       };
4375     } catch (Dali::DaliException e) {
4376       {
4377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4378       };
4379     } catch (...) {
4380       {
4381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4382       };
4383     }
4384   }
4385
4386   jresult = (void *)result;
4387   return jresult;
4388 }
4389
4390
4391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4392   void * jresult ;
4393   Dali::Vector2 *result = 0 ;
4394
4395   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4396   jresult = (void *)result;
4397   return jresult;
4398 }
4399
4400
4401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4402   void * jresult ;
4403   Dali::Vector2 *result = 0 ;
4404
4405   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4406   jresult = (void *)result;
4407   return jresult;
4408 }
4409
4410
4411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4412   void * jresult ;
4413   Dali::Vector2 *result = 0 ;
4414
4415   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4416   jresult = (void *)result;
4417   return jresult;
4418 }
4419
4420
4421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4422   void * jresult ;
4423   Dali::Vector2 *result = 0 ;
4424
4425   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4426   jresult = (void *)result;
4427   return jresult;
4428 }
4429
4430
4431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4432   void * jresult ;
4433   Dali::Vector2 *result = 0 ;
4434
4435   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4436   jresult = (void *)result;
4437   return jresult;
4438 }
4439
4440
4441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4442   void * jresult ;
4443   Dali::Vector2 *result = 0 ;
4444
4445   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4446   jresult = (void *)result;
4447   return jresult;
4448 }
4449
4450
4451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4452   void * jresult ;
4453   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4454   float *arg2 = (float *) 0 ;
4455   Dali::Vector2 *result = 0 ;
4456
4457   arg1 = (Dali::Vector2 *)jarg1;
4458   arg2 = jarg2;
4459   {
4460     try {
4461       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4462     } catch (std::out_of_range& e) {
4463       {
4464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4465       };
4466     } catch (std::exception& e) {
4467       {
4468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4469       };
4470     } catch (Dali::DaliException e) {
4471       {
4472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4473       };
4474     } catch (...) {
4475       {
4476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4477       };
4478     }
4479   }
4480
4481   jresult = (void *)result;
4482
4483
4484   return jresult;
4485 }
4486
4487
4488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4489   void * jresult ;
4490   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4491   Dali::Vector3 *arg2 = 0 ;
4492   Dali::Vector2 *result = 0 ;
4493
4494   arg1 = (Dali::Vector2 *)jarg1;
4495   arg2 = (Dali::Vector3 *)jarg2;
4496   if (!arg2) {
4497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4498     return 0;
4499   }
4500   {
4501     try {
4502       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4503     } catch (std::out_of_range& e) {
4504       {
4505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (std::exception& e) {
4508       {
4509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (Dali::DaliException e) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4514       };
4515     } catch (...) {
4516       {
4517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4518       };
4519     }
4520   }
4521
4522   jresult = (void *)result;
4523   return jresult;
4524 }
4525
4526
4527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4528   void * jresult ;
4529   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4530   Dali::Vector4 *arg2 = 0 ;
4531   Dali::Vector2 *result = 0 ;
4532
4533   arg1 = (Dali::Vector2 *)jarg1;
4534   arg2 = (Dali::Vector4 *)jarg2;
4535   if (!arg2) {
4536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4537     return 0;
4538   }
4539   {
4540     try {
4541       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4542     } catch (std::out_of_range& e) {
4543       {
4544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (std::exception& e) {
4547       {
4548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (Dali::DaliException e) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4553       };
4554     } catch (...) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4557       };
4558     }
4559   }
4560
4561   jresult = (void *)result;
4562   return jresult;
4563 }
4564
4565
4566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4567   void * jresult ;
4568   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4569   Dali::Vector2 *arg2 = 0 ;
4570   Dali::Vector2 result;
4571
4572   arg1 = (Dali::Vector2 *)jarg1;
4573   arg2 = (Dali::Vector2 *)jarg2;
4574   if (!arg2) {
4575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4576     return 0;
4577   }
4578   {
4579     try {
4580       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4581     } catch (std::out_of_range& e) {
4582       {
4583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (std::exception& e) {
4586       {
4587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (Dali::DaliException e) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4592       };
4593     } catch (...) {
4594       {
4595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4596       };
4597     }
4598   }
4599
4600   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4601   return jresult;
4602 }
4603
4604
4605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4606   void * jresult ;
4607   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4608   Dali::Vector2 *arg2 = 0 ;
4609   Dali::Vector2 *result = 0 ;
4610
4611   arg1 = (Dali::Vector2 *)jarg1;
4612   arg2 = (Dali::Vector2 *)jarg2;
4613   if (!arg2) {
4614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4615     return 0;
4616   }
4617   {
4618     try {
4619       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4620     } catch (std::out_of_range& e) {
4621       {
4622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4623       };
4624     } catch (std::exception& e) {
4625       {
4626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (Dali::DaliException e) {
4629       {
4630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4631       };
4632     } catch (...) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4635       };
4636     }
4637   }
4638
4639   jresult = (void *)result;
4640   return jresult;
4641 }
4642
4643
4644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4645   void * jresult ;
4646   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4647   Dali::Vector2 *arg2 = 0 ;
4648   Dali::Vector2 result;
4649
4650   arg1 = (Dali::Vector2 *)jarg1;
4651   arg2 = (Dali::Vector2 *)jarg2;
4652   if (!arg2) {
4653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4654     return 0;
4655   }
4656   {
4657     try {
4658       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4659     } catch (std::out_of_range& e) {
4660       {
4661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (std::exception& e) {
4664       {
4665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (Dali::DaliException e) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4670       };
4671     } catch (...) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4674       };
4675     }
4676   }
4677
4678   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4679   return jresult;
4680 }
4681
4682
4683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4684   void * jresult ;
4685   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4686   Dali::Vector2 *arg2 = 0 ;
4687   Dali::Vector2 *result = 0 ;
4688
4689   arg1 = (Dali::Vector2 *)jarg1;
4690   arg2 = (Dali::Vector2 *)jarg2;
4691   if (!arg2) {
4692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4693     return 0;
4694   }
4695   {
4696     try {
4697       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4698     } catch (std::out_of_range& e) {
4699       {
4700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (std::exception& e) {
4703       {
4704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4705       };
4706     } catch (Dali::DaliException e) {
4707       {
4708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4709       };
4710     } catch (...) {
4711       {
4712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4713       };
4714     }
4715   }
4716
4717   jresult = (void *)result;
4718   return jresult;
4719 }
4720
4721
4722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4723   void * jresult ;
4724   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4725   Dali::Vector2 *arg2 = 0 ;
4726   Dali::Vector2 result;
4727
4728   arg1 = (Dali::Vector2 *)jarg1;
4729   arg2 = (Dali::Vector2 *)jarg2;
4730   if (!arg2) {
4731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4732     return 0;
4733   }
4734   {
4735     try {
4736       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4737     } catch (std::out_of_range& e) {
4738       {
4739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4740       };
4741     } catch (std::exception& e) {
4742       {
4743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4744       };
4745     } catch (Dali::DaliException e) {
4746       {
4747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4748       };
4749     } catch (...) {
4750       {
4751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4752       };
4753     }
4754   }
4755
4756   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4757   return jresult;
4758 }
4759
4760
4761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4762   void * jresult ;
4763   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4764   float arg2 ;
4765   Dali::Vector2 result;
4766
4767   arg1 = (Dali::Vector2 *)jarg1;
4768   arg2 = (float)jarg2;
4769   {
4770     try {
4771       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4772     } catch (std::out_of_range& e) {
4773       {
4774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4775       };
4776     } catch (std::exception& e) {
4777       {
4778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4779       };
4780     } catch (Dali::DaliException e) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4783       };
4784     } catch (...) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4787       };
4788     }
4789   }
4790
4791   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4792   return jresult;
4793 }
4794
4795
4796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4797   void * jresult ;
4798   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4799   Dali::Vector2 *arg2 = 0 ;
4800   Dali::Vector2 *result = 0 ;
4801
4802   arg1 = (Dali::Vector2 *)jarg1;
4803   arg2 = (Dali::Vector2 *)jarg2;
4804   if (!arg2) {
4805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4806     return 0;
4807   }
4808   {
4809     try {
4810       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4811     } catch (std::out_of_range& e) {
4812       {
4813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4814       };
4815     } catch (std::exception& e) {
4816       {
4817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4818       };
4819     } catch (Dali::DaliException e) {
4820       {
4821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4822       };
4823     } catch (...) {
4824       {
4825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4826       };
4827     }
4828   }
4829
4830   jresult = (void *)result;
4831   return jresult;
4832 }
4833
4834
4835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4836   void * jresult ;
4837   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4838   float arg2 ;
4839   Dali::Vector2 *result = 0 ;
4840
4841   arg1 = (Dali::Vector2 *)jarg1;
4842   arg2 = (float)jarg2;
4843   {
4844     try {
4845       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4846     } catch (std::out_of_range& e) {
4847       {
4848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (std::exception& e) {
4851       {
4852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (Dali::DaliException e) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4857       };
4858     } catch (...) {
4859       {
4860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4861       };
4862     }
4863   }
4864
4865   jresult = (void *)result;
4866   return jresult;
4867 }
4868
4869
4870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4871   void * jresult ;
4872   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4873   Dali::Vector2 *arg2 = 0 ;
4874   Dali::Vector2 result;
4875
4876   arg1 = (Dali::Vector2 *)jarg1;
4877   arg2 = (Dali::Vector2 *)jarg2;
4878   if (!arg2) {
4879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4880     return 0;
4881   }
4882   {
4883     try {
4884       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4885     } catch (std::out_of_range& e) {
4886       {
4887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4888       };
4889     } catch (std::exception& e) {
4890       {
4891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4892       };
4893     } catch (Dali::DaliException e) {
4894       {
4895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4896       };
4897     } catch (...) {
4898       {
4899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4900       };
4901     }
4902   }
4903
4904   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4905   return jresult;
4906 }
4907
4908
4909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4910   void * jresult ;
4911   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4912   float arg2 ;
4913   Dali::Vector2 result;
4914
4915   arg1 = (Dali::Vector2 *)jarg1;
4916   arg2 = (float)jarg2;
4917   {
4918     try {
4919       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4920     } catch (std::out_of_range& e) {
4921       {
4922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4923       };
4924     } catch (std::exception& e) {
4925       {
4926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4927       };
4928     } catch (Dali::DaliException e) {
4929       {
4930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4931       };
4932     } catch (...) {
4933       {
4934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4935       };
4936     }
4937   }
4938
4939   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4940   return jresult;
4941 }
4942
4943
4944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4945   void * jresult ;
4946   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4947   Dali::Vector2 *arg2 = 0 ;
4948   Dali::Vector2 *result = 0 ;
4949
4950   arg1 = (Dali::Vector2 *)jarg1;
4951   arg2 = (Dali::Vector2 *)jarg2;
4952   if (!arg2) {
4953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4954     return 0;
4955   }
4956   {
4957     try {
4958       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4959     } catch (std::out_of_range& e) {
4960       {
4961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4962       };
4963     } catch (std::exception& e) {
4964       {
4965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4966       };
4967     } catch (Dali::DaliException e) {
4968       {
4969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4970       };
4971     } catch (...) {
4972       {
4973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4974       };
4975     }
4976   }
4977
4978   jresult = (void *)result;
4979   return jresult;
4980 }
4981
4982
4983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4984   void * jresult ;
4985   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4986   float arg2 ;
4987   Dali::Vector2 *result = 0 ;
4988
4989   arg1 = (Dali::Vector2 *)jarg1;
4990   arg2 = (float)jarg2;
4991   {
4992     try {
4993       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4994     } catch (std::out_of_range& e) {
4995       {
4996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4997       };
4998     } catch (std::exception& e) {
4999       {
5000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (Dali::DaliException e) {
5003       {
5004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5005       };
5006     } catch (...) {
5007       {
5008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5009       };
5010     }
5011   }
5012
5013   jresult = (void *)result;
5014   return jresult;
5015 }
5016
5017
5018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5019   void * jresult ;
5020   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5021   Dali::Vector2 result;
5022
5023   arg1 = (Dali::Vector2 *)jarg1;
5024   {
5025     try {
5026       result = ((Dali::Vector2 const *)arg1)->operator -();
5027     } catch (std::out_of_range& e) {
5028       {
5029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (std::exception& e) {
5032       {
5033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (Dali::DaliException e) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5038       };
5039     } catch (...) {
5040       {
5041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5042       };
5043     }
5044   }
5045
5046   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5047   return jresult;
5048 }
5049
5050
5051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5052   unsigned int jresult ;
5053   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5054   Dali::Vector2 *arg2 = 0 ;
5055   bool result;
5056
5057   arg1 = (Dali::Vector2 *)jarg1;
5058   arg2 = (Dali::Vector2 *)jarg2;
5059   if (!arg2) {
5060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5061     return 0;
5062   }
5063   {
5064     try {
5065       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5066     } catch (std::out_of_range& e) {
5067       {
5068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (std::exception& e) {
5071       {
5072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (Dali::DaliException e) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5077       };
5078     } catch (...) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5081       };
5082     }
5083   }
5084
5085   jresult = result;
5086   return jresult;
5087 }
5088
5089
5090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5091   unsigned int jresult ;
5092   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5093   Dali::Vector2 *arg2 = 0 ;
5094   bool result;
5095
5096   arg1 = (Dali::Vector2 *)jarg1;
5097   arg2 = (Dali::Vector2 *)jarg2;
5098   if (!arg2) {
5099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5100     return 0;
5101   }
5102   {
5103     try {
5104       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5105     } catch (std::out_of_range& e) {
5106       {
5107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5108       };
5109     } catch (std::exception& e) {
5110       {
5111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (Dali::DaliException e) {
5114       {
5115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5116       };
5117     } catch (...) {
5118       {
5119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5120       };
5121     }
5122   }
5123
5124   jresult = result;
5125   return jresult;
5126 }
5127
5128
5129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5130   float jresult ;
5131   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5132   unsigned int arg2 ;
5133   float *result = 0 ;
5134
5135   arg1 = (Dali::Vector2 *)jarg1;
5136   arg2 = (unsigned int)jarg2;
5137   {
5138     try {
5139       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5140     } catch (std::out_of_range& e) {
5141       {
5142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5143       };
5144     } catch (std::exception& e) {
5145       {
5146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5147       };
5148     } catch (Dali::DaliException e) {
5149       {
5150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5151       };
5152     } catch (...) {
5153       {
5154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5155       };
5156     }
5157   }
5158
5159   jresult = *result;
5160   return jresult;
5161 }
5162
5163
5164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5165   float jresult ;
5166   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5167   float result;
5168
5169   arg1 = (Dali::Vector2 *)jarg1;
5170   {
5171     try {
5172       result = (float)((Dali::Vector2 const *)arg1)->Length();
5173     } catch (std::out_of_range& e) {
5174       {
5175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5176       };
5177     } catch (std::exception& e) {
5178       {
5179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5180       };
5181     } catch (Dali::DaliException e) {
5182       {
5183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5184       };
5185     } catch (...) {
5186       {
5187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5188       };
5189     }
5190   }
5191
5192   jresult = result;
5193   return jresult;
5194 }
5195
5196
5197 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5198   float jresult ;
5199   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5200   float result;
5201
5202   arg1 = (Dali::Vector2 *)jarg1;
5203   {
5204     try {
5205       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5206     } catch (std::out_of_range& e) {
5207       {
5208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5209       };
5210     } catch (std::exception& e) {
5211       {
5212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5213       };
5214     } catch (Dali::DaliException e) {
5215       {
5216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5217       };
5218     } catch (...) {
5219       {
5220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5221       };
5222     }
5223   }
5224
5225   jresult = result;
5226   return jresult;
5227 }
5228
5229
5230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5231   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5232
5233   arg1 = (Dali::Vector2 *)jarg1;
5234   {
5235     try {
5236       (arg1)->Normalize();
5237     } catch (std::out_of_range& e) {
5238       {
5239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5240       };
5241     } catch (std::exception& e) {
5242       {
5243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5244       };
5245     } catch (Dali::DaliException e) {
5246       {
5247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5248       };
5249     } catch (...) {
5250       {
5251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5252       };
5253     }
5254   }
5255
5256 }
5257
5258
5259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5260   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5261   Dali::Vector2 *arg2 = 0 ;
5262   Dali::Vector2 *arg3 = 0 ;
5263
5264   arg1 = (Dali::Vector2 *)jarg1;
5265   arg2 = (Dali::Vector2 *)jarg2;
5266   if (!arg2) {
5267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5268     return ;
5269   }
5270   arg3 = (Dali::Vector2 *)jarg3;
5271   if (!arg3) {
5272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5273     return ;
5274   }
5275   {
5276     try {
5277       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5278     } catch (std::out_of_range& e) {
5279       {
5280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5281       };
5282     } catch (std::exception& e) {
5283       {
5284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5285       };
5286     } catch (Dali::DaliException e) {
5287       {
5288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5289       };
5290     } catch (...) {
5291       {
5292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5293       };
5294     }
5295   }
5296
5297 }
5298
5299
5300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5301   void * jresult ;
5302   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5303   float *result = 0 ;
5304
5305   arg1 = (Dali::Vector2 *)jarg1;
5306   {
5307     try {
5308       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5309     } catch (std::out_of_range& e) {
5310       {
5311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5312       };
5313     } catch (std::exception& e) {
5314       {
5315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5316       };
5317     } catch (Dali::DaliException e) {
5318       {
5319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5320       };
5321     } catch (...) {
5322       {
5323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5324       };
5325     }
5326   }
5327
5328   jresult = (void *)result;
5329   return jresult;
5330 }
5331
5332
5333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5334   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5335   float arg2 ;
5336
5337   arg1 = (Dali::Vector2 *)jarg1;
5338   arg2 = (float)jarg2;
5339   if (arg1) (arg1)->x = arg2;
5340 }
5341
5342
5343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5344   float jresult ;
5345   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5346   float result;
5347
5348   arg1 = (Dali::Vector2 *)jarg1;
5349   result = (float) ((arg1)->x);
5350   jresult = result;
5351   return jresult;
5352 }
5353
5354
5355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5356   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5357   float arg2 ;
5358
5359   arg1 = (Dali::Vector2 *)jarg1;
5360   arg2 = (float)jarg2;
5361   if (arg1) (arg1)->width = arg2;
5362 }
5363
5364
5365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5366   float jresult ;
5367   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5368   float result;
5369
5370   arg1 = (Dali::Vector2 *)jarg1;
5371   result = (float) ((arg1)->width);
5372   jresult = result;
5373   return jresult;
5374 }
5375
5376
5377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5378   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5379   float arg2 ;
5380
5381   arg1 = (Dali::Vector2 *)jarg1;
5382   arg2 = (float)jarg2;
5383   if (arg1) (arg1)->y = arg2;
5384 }
5385
5386
5387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5388   float jresult ;
5389   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5390   float result;
5391
5392   arg1 = (Dali::Vector2 *)jarg1;
5393   result = (float) ((arg1)->y);
5394   jresult = result;
5395   return jresult;
5396 }
5397
5398
5399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5400   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5401   float arg2 ;
5402
5403   arg1 = (Dali::Vector2 *)jarg1;
5404   arg2 = (float)jarg2;
5405   if (arg1) (arg1)->height = arg2;
5406 }
5407
5408
5409 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5410   float jresult ;
5411   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5412   float result;
5413
5414   arg1 = (Dali::Vector2 *)jarg1;
5415   result = (float) ((arg1)->height);
5416   jresult = result;
5417   return jresult;
5418 }
5419
5420
5421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5422   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5423
5424   arg1 = (Dali::Vector2 *)jarg1;
5425   {
5426     try {
5427       delete arg1;
5428     } catch (std::out_of_range& e) {
5429       {
5430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5431       };
5432     } catch (std::exception& e) {
5433       {
5434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5435       };
5436     } catch (Dali::DaliException e) {
5437       {
5438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5439       };
5440     } catch (...) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5443       };
5444     }
5445   }
5446
5447 }
5448
5449
5450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5451   void * jresult ;
5452   Dali::Vector2 *arg1 = 0 ;
5453   Dali::Vector2 *arg2 = 0 ;
5454   Dali::Vector2 result;
5455
5456   arg1 = (Dali::Vector2 *)jarg1;
5457   if (!arg1) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5459     return 0;
5460   }
5461   arg2 = (Dali::Vector2 *)jarg2;
5462   if (!arg2) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   {
5467     try {
5468       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5469     } catch (std::out_of_range& e) {
5470       {
5471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (std::exception& e) {
5474       {
5475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (Dali::DaliException e) {
5478       {
5479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5480       };
5481     } catch (...) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5484       };
5485     }
5486   }
5487
5488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5489   return jresult;
5490 }
5491
5492
5493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5494   void * jresult ;
5495   Dali::Vector2 *arg1 = 0 ;
5496   Dali::Vector2 *arg2 = 0 ;
5497   Dali::Vector2 result;
5498
5499   arg1 = (Dali::Vector2 *)jarg1;
5500   if (!arg1) {
5501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5502     return 0;
5503   }
5504   arg2 = (Dali::Vector2 *)jarg2;
5505   if (!arg2) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   {
5510     try {
5511       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5512     } catch (std::out_of_range& e) {
5513       {
5514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5515       };
5516     } catch (std::exception& e) {
5517       {
5518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (Dali::DaliException e) {
5521       {
5522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5523       };
5524     } catch (...) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5527       };
5528     }
5529   }
5530
5531   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5532   return jresult;
5533 }
5534
5535
5536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5537   void * jresult ;
5538   Dali::Vector2 *arg1 = 0 ;
5539   float *arg2 = 0 ;
5540   float *arg3 = 0 ;
5541   float temp2 ;
5542   float temp3 ;
5543   Dali::Vector2 result;
5544
5545   arg1 = (Dali::Vector2 *)jarg1;
5546   if (!arg1) {
5547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5548     return 0;
5549   }
5550   temp2 = (float)jarg2;
5551   arg2 = &temp2;
5552   temp3 = (float)jarg3;
5553   arg3 = &temp3;
5554   {
5555     try {
5556       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5557     } catch (std::out_of_range& e) {
5558       {
5559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5560       };
5561     } catch (std::exception& e) {
5562       {
5563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5564       };
5565     } catch (Dali::DaliException e) {
5566       {
5567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5568       };
5569     } catch (...) {
5570       {
5571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5572       };
5573     }
5574   }
5575
5576   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5577   return jresult;
5578 }
5579
5580
5581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5582   void * jresult ;
5583   Dali::Vector3 *result = 0 ;
5584
5585   {
5586     try {
5587       result = (Dali::Vector3 *)new Dali::Vector3();
5588     } catch (std::out_of_range& e) {
5589       {
5590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5591       };
5592     } catch (std::exception& e) {
5593       {
5594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5595       };
5596     } catch (Dali::DaliException e) {
5597       {
5598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5599       };
5600     } catch (...) {
5601       {
5602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5603       };
5604     }
5605   }
5606
5607   jresult = (void *)result;
5608   return jresult;
5609 }
5610
5611
5612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5613   void * jresult ;
5614   float arg1 ;
5615   float arg2 ;
5616   float arg3 ;
5617   Dali::Vector3 *result = 0 ;
5618
5619   arg1 = (float)jarg1;
5620   arg2 = (float)jarg2;
5621   arg3 = (float)jarg3;
5622   {
5623     try {
5624       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5625     } catch (std::out_of_range& e) {
5626       {
5627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5628       };
5629     } catch (std::exception& e) {
5630       {
5631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5632       };
5633     } catch (Dali::DaliException e) {
5634       {
5635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5636       };
5637     } catch (...) {
5638       {
5639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5640       };
5641     }
5642   }
5643
5644   jresult = (void *)result;
5645   return jresult;
5646 }
5647
5648
5649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5650   void * jresult ;
5651   float *arg1 = (float *) 0 ;
5652   Dali::Vector3 *result = 0 ;
5653
5654   arg1 = jarg1;
5655   {
5656     try {
5657       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5658     } catch (std::out_of_range& e) {
5659       {
5660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (std::exception& e) {
5663       {
5664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (Dali::DaliException e) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5669       };
5670     } catch (...) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5673       };
5674     }
5675   }
5676
5677   jresult = (void *)result;
5678
5679
5680   return jresult;
5681 }
5682
5683
5684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5685   void * jresult ;
5686   Dali::Vector2 *arg1 = 0 ;
5687   Dali::Vector3 *result = 0 ;
5688
5689   arg1 = (Dali::Vector2 *)jarg1;
5690   if (!arg1) {
5691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5692     return 0;
5693   }
5694   {
5695     try {
5696       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5697     } catch (std::out_of_range& e) {
5698       {
5699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (std::exception& e) {
5702       {
5703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5704       };
5705     } catch (Dali::DaliException e) {
5706       {
5707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5708       };
5709     } catch (...) {
5710       {
5711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5712       };
5713     }
5714   }
5715
5716   jresult = (void *)result;
5717   return jresult;
5718 }
5719
5720
5721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5722   void * jresult ;
5723   Dali::Vector4 *arg1 = 0 ;
5724   Dali::Vector3 *result = 0 ;
5725
5726   arg1 = (Dali::Vector4 *)jarg1;
5727   if (!arg1) {
5728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5729     return 0;
5730   }
5731   {
5732     try {
5733       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5734     } catch (std::out_of_range& e) {
5735       {
5736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5737       };
5738     } catch (std::exception& e) {
5739       {
5740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5741       };
5742     } catch (Dali::DaliException e) {
5743       {
5744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5745       };
5746     } catch (...) {
5747       {
5748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5749       };
5750     }
5751   }
5752
5753   jresult = (void *)result;
5754   return jresult;
5755 }
5756
5757
5758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5759   void * jresult ;
5760   Dali::Vector3 *result = 0 ;
5761
5762   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5763   jresult = (void *)result;
5764   return jresult;
5765 }
5766
5767
5768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5769   void * jresult ;
5770   Dali::Vector3 *result = 0 ;
5771
5772   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5773   jresult = (void *)result;
5774   return jresult;
5775 }
5776
5777
5778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5779   void * jresult ;
5780   Dali::Vector3 *result = 0 ;
5781
5782   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5783   jresult = (void *)result;
5784   return jresult;
5785 }
5786
5787
5788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5789   void * jresult ;
5790   Dali::Vector3 *result = 0 ;
5791
5792   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5793   jresult = (void *)result;
5794   return jresult;
5795 }
5796
5797
5798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5799   void * jresult ;
5800   Dali::Vector3 *result = 0 ;
5801
5802   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5803   jresult = (void *)result;
5804   return jresult;
5805 }
5806
5807
5808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5809   void * jresult ;
5810   Dali::Vector3 *result = 0 ;
5811
5812   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5813   jresult = (void *)result;
5814   return jresult;
5815 }
5816
5817
5818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5819   void * jresult ;
5820   Dali::Vector3 *result = 0 ;
5821
5822   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5823   jresult = (void *)result;
5824   return jresult;
5825 }
5826
5827
5828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5829   void * jresult ;
5830   Dali::Vector3 *result = 0 ;
5831
5832   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5833   jresult = (void *)result;
5834   return jresult;
5835 }
5836
5837
5838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5839   void * jresult ;
5840   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5841   float *arg2 = (float *) 0 ;
5842   Dali::Vector3 *result = 0 ;
5843
5844   arg1 = (Dali::Vector3 *)jarg1;
5845   arg2 = jarg2;
5846   {
5847     try {
5848       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5849     } catch (std::out_of_range& e) {
5850       {
5851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5852       };
5853     } catch (std::exception& e) {
5854       {
5855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (Dali::DaliException e) {
5858       {
5859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5860       };
5861     } catch (...) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5864       };
5865     }
5866   }
5867
5868   jresult = (void *)result;
5869
5870
5871   return jresult;
5872 }
5873
5874
5875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5876   void * jresult ;
5877   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5878   Dali::Vector2 *arg2 = 0 ;
5879   Dali::Vector3 *result = 0 ;
5880
5881   arg1 = (Dali::Vector3 *)jarg1;
5882   arg2 = (Dali::Vector2 *)jarg2;
5883   if (!arg2) {
5884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5885     return 0;
5886   }
5887   {
5888     try {
5889       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5890     } catch (std::out_of_range& e) {
5891       {
5892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (std::exception& e) {
5895       {
5896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (Dali::DaliException e) {
5899       {
5900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5901       };
5902     } catch (...) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5905       };
5906     }
5907   }
5908
5909   jresult = (void *)result;
5910   return jresult;
5911 }
5912
5913
5914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5915   void * jresult ;
5916   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5917   Dali::Vector4 *arg2 = 0 ;
5918   Dali::Vector3 *result = 0 ;
5919
5920   arg1 = (Dali::Vector3 *)jarg1;
5921   arg2 = (Dali::Vector4 *)jarg2;
5922   if (!arg2) {
5923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5924     return 0;
5925   }
5926   {
5927     try {
5928       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5929     } catch (std::out_of_range& e) {
5930       {
5931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (std::exception& e) {
5934       {
5935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (Dali::DaliException e) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5940       };
5941     } catch (...) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5944       };
5945     }
5946   }
5947
5948   jresult = (void *)result;
5949   return jresult;
5950 }
5951
5952
5953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5954   void * jresult ;
5955   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5956   Dali::Vector3 *arg2 = 0 ;
5957   Dali::Vector3 result;
5958
5959   arg1 = (Dali::Vector3 *)jarg1;
5960   arg2 = (Dali::Vector3 *)jarg2;
5961   if (!arg2) {
5962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5963     return 0;
5964   }
5965   {
5966     try {
5967       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5968     } catch (std::out_of_range& e) {
5969       {
5970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (std::exception& e) {
5973       {
5974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5975       };
5976     } catch (Dali::DaliException e) {
5977       {
5978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5979       };
5980     } catch (...) {
5981       {
5982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5983       };
5984     }
5985   }
5986
5987   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5988   return jresult;
5989 }
5990
5991
5992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5993   void * jresult ;
5994   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5995   Dali::Vector3 *arg2 = 0 ;
5996   Dali::Vector3 *result = 0 ;
5997
5998   arg1 = (Dali::Vector3 *)jarg1;
5999   arg2 = (Dali::Vector3 *)jarg2;
6000   if (!arg2) {
6001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6002     return 0;
6003   }
6004   {
6005     try {
6006       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6007     } catch (std::out_of_range& e) {
6008       {
6009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6010       };
6011     } catch (std::exception& e) {
6012       {
6013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (Dali::DaliException e) {
6016       {
6017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6018       };
6019     } catch (...) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6022       };
6023     }
6024   }
6025
6026   jresult = (void *)result;
6027   return jresult;
6028 }
6029
6030
6031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6032   void * jresult ;
6033   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6034   Dali::Vector3 *arg2 = 0 ;
6035   Dali::Vector3 result;
6036
6037   arg1 = (Dali::Vector3 *)jarg1;
6038   arg2 = (Dali::Vector3 *)jarg2;
6039   if (!arg2) {
6040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6041     return 0;
6042   }
6043   {
6044     try {
6045       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6046     } catch (std::out_of_range& e) {
6047       {
6048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (std::exception& e) {
6051       {
6052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (Dali::DaliException e) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6057       };
6058     } catch (...) {
6059       {
6060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6061       };
6062     }
6063   }
6064
6065   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6066   return jresult;
6067 }
6068
6069
6070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6071   void * jresult ;
6072   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6073   Dali::Vector3 *arg2 = 0 ;
6074   Dali::Vector3 *result = 0 ;
6075
6076   arg1 = (Dali::Vector3 *)jarg1;
6077   arg2 = (Dali::Vector3 *)jarg2;
6078   if (!arg2) {
6079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6080     return 0;
6081   }
6082   {
6083     try {
6084       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6085     } catch (std::out_of_range& e) {
6086       {
6087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (std::exception& e) {
6090       {
6091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (Dali::DaliException e) {
6094       {
6095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6096       };
6097     } catch (...) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6100       };
6101     }
6102   }
6103
6104   jresult = (void *)result;
6105   return jresult;
6106 }
6107
6108
6109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6110   void * jresult ;
6111   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6112   Dali::Vector3 *arg2 = 0 ;
6113   Dali::Vector3 result;
6114
6115   arg1 = (Dali::Vector3 *)jarg1;
6116   arg2 = (Dali::Vector3 *)jarg2;
6117   if (!arg2) {
6118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6119     return 0;
6120   }
6121   {
6122     try {
6123       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6124     } catch (std::out_of_range& e) {
6125       {
6126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6127       };
6128     } catch (std::exception& e) {
6129       {
6130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6131       };
6132     } catch (Dali::DaliException e) {
6133       {
6134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6135       };
6136     } catch (...) {
6137       {
6138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6139       };
6140     }
6141   }
6142
6143   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6144   return jresult;
6145 }
6146
6147
6148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6149   void * jresult ;
6150   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6151   float arg2 ;
6152   Dali::Vector3 result;
6153
6154   arg1 = (Dali::Vector3 *)jarg1;
6155   arg2 = (float)jarg2;
6156   {
6157     try {
6158       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6159     } catch (std::out_of_range& e) {
6160       {
6161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6162       };
6163     } catch (std::exception& e) {
6164       {
6165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (Dali::DaliException e) {
6168       {
6169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6170       };
6171     } catch (...) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6174       };
6175     }
6176   }
6177
6178   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6179   return jresult;
6180 }
6181
6182
6183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6184   void * jresult ;
6185   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6186   Dali::Vector3 *arg2 = 0 ;
6187   Dali::Vector3 *result = 0 ;
6188
6189   arg1 = (Dali::Vector3 *)jarg1;
6190   arg2 = (Dali::Vector3 *)jarg2;
6191   if (!arg2) {
6192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6193     return 0;
6194   }
6195   {
6196     try {
6197       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6198     } catch (std::out_of_range& e) {
6199       {
6200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6201       };
6202     } catch (std::exception& e) {
6203       {
6204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6205       };
6206     } catch (Dali::DaliException e) {
6207       {
6208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6209       };
6210     } catch (...) {
6211       {
6212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6213       };
6214     }
6215   }
6216
6217   jresult = (void *)result;
6218   return jresult;
6219 }
6220
6221
6222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6223   void * jresult ;
6224   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6225   float arg2 ;
6226   Dali::Vector3 *result = 0 ;
6227
6228   arg1 = (Dali::Vector3 *)jarg1;
6229   arg2 = (float)jarg2;
6230   {
6231     try {
6232       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6233     } catch (std::out_of_range& e) {
6234       {
6235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6236       };
6237     } catch (std::exception& e) {
6238       {
6239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6240       };
6241     } catch (Dali::DaliException e) {
6242       {
6243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6244       };
6245     } catch (...) {
6246       {
6247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6248       };
6249     }
6250   }
6251
6252   jresult = (void *)result;
6253   return jresult;
6254 }
6255
6256
6257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6258   void * jresult ;
6259   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6260   Dali::Quaternion *arg2 = 0 ;
6261   Dali::Vector3 *result = 0 ;
6262
6263   arg1 = (Dali::Vector3 *)jarg1;
6264   arg2 = (Dali::Quaternion *)jarg2;
6265   if (!arg2) {
6266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6267     return 0;
6268   }
6269   {
6270     try {
6271       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6272     } catch (std::out_of_range& e) {
6273       {
6274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6275       };
6276     } catch (std::exception& e) {
6277       {
6278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6279       };
6280     } catch (Dali::DaliException e) {
6281       {
6282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6283       };
6284     } catch (...) {
6285       {
6286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6287       };
6288     }
6289   }
6290
6291   jresult = (void *)result;
6292   return jresult;
6293 }
6294
6295
6296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6297   void * jresult ;
6298   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6299   Dali::Vector3 *arg2 = 0 ;
6300   Dali::Vector3 result;
6301
6302   arg1 = (Dali::Vector3 *)jarg1;
6303   arg2 = (Dali::Vector3 *)jarg2;
6304   if (!arg2) {
6305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6306     return 0;
6307   }
6308   {
6309     try {
6310       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6311     } catch (std::out_of_range& e) {
6312       {
6313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6314       };
6315     } catch (std::exception& e) {
6316       {
6317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6318       };
6319     } catch (Dali::DaliException e) {
6320       {
6321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6322       };
6323     } catch (...) {
6324       {
6325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6326       };
6327     }
6328   }
6329
6330   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6331   return jresult;
6332 }
6333
6334
6335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6336   void * jresult ;
6337   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6338   float arg2 ;
6339   Dali::Vector3 result;
6340
6341   arg1 = (Dali::Vector3 *)jarg1;
6342   arg2 = (float)jarg2;
6343   {
6344     try {
6345       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6346     } catch (std::out_of_range& e) {
6347       {
6348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6349       };
6350     } catch (std::exception& e) {
6351       {
6352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6353       };
6354     } catch (Dali::DaliException e) {
6355       {
6356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6357       };
6358     } catch (...) {
6359       {
6360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6361       };
6362     }
6363   }
6364
6365   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6366   return jresult;
6367 }
6368
6369
6370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6371   void * jresult ;
6372   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6373   Dali::Vector3 *arg2 = 0 ;
6374   Dali::Vector3 *result = 0 ;
6375
6376   arg1 = (Dali::Vector3 *)jarg1;
6377   arg2 = (Dali::Vector3 *)jarg2;
6378   if (!arg2) {
6379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6380     return 0;
6381   }
6382   {
6383     try {
6384       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6385     } catch (std::out_of_range& e) {
6386       {
6387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6388       };
6389     } catch (std::exception& e) {
6390       {
6391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6392       };
6393     } catch (Dali::DaliException e) {
6394       {
6395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6396       };
6397     } catch (...) {
6398       {
6399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6400       };
6401     }
6402   }
6403
6404   jresult = (void *)result;
6405   return jresult;
6406 }
6407
6408
6409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6410   void * jresult ;
6411   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6412   float arg2 ;
6413   Dali::Vector3 *result = 0 ;
6414
6415   arg1 = (Dali::Vector3 *)jarg1;
6416   arg2 = (float)jarg2;
6417   {
6418     try {
6419       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6420     } catch (std::out_of_range& e) {
6421       {
6422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6423       };
6424     } catch (std::exception& e) {
6425       {
6426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6427       };
6428     } catch (Dali::DaliException e) {
6429       {
6430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6431       };
6432     } catch (...) {
6433       {
6434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6435       };
6436     }
6437   }
6438
6439   jresult = (void *)result;
6440   return jresult;
6441 }
6442
6443
6444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6445   void * jresult ;
6446   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6447   Dali::Vector3 result;
6448
6449   arg1 = (Dali::Vector3 *)jarg1;
6450   {
6451     try {
6452       result = ((Dali::Vector3 const *)arg1)->operator -();
6453     } catch (std::out_of_range& e) {
6454       {
6455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6456       };
6457     } catch (std::exception& e) {
6458       {
6459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (Dali::DaliException e) {
6462       {
6463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6464       };
6465     } catch (...) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6468       };
6469     }
6470   }
6471
6472   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6473   return jresult;
6474 }
6475
6476
6477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6478   unsigned int jresult ;
6479   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6480   Dali::Vector3 *arg2 = 0 ;
6481   bool result;
6482
6483   arg1 = (Dali::Vector3 *)jarg1;
6484   arg2 = (Dali::Vector3 *)jarg2;
6485   if (!arg2) {
6486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6487     return 0;
6488   }
6489   {
6490     try {
6491       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6492     } catch (std::out_of_range& e) {
6493       {
6494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6495       };
6496     } catch (std::exception& e) {
6497       {
6498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6499       };
6500     } catch (Dali::DaliException e) {
6501       {
6502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6503       };
6504     } catch (...) {
6505       {
6506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6507       };
6508     }
6509   }
6510
6511   jresult = result;
6512   return jresult;
6513 }
6514
6515
6516 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6517   unsigned int jresult ;
6518   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6519   Dali::Vector3 *arg2 = 0 ;
6520   bool result;
6521
6522   arg1 = (Dali::Vector3 *)jarg1;
6523   arg2 = (Dali::Vector3 *)jarg2;
6524   if (!arg2) {
6525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6526     return 0;
6527   }
6528   {
6529     try {
6530       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6531     } catch (std::out_of_range& e) {
6532       {
6533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6534       };
6535     } catch (std::exception& e) {
6536       {
6537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (Dali::DaliException e) {
6540       {
6541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6542       };
6543     } catch (...) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6546       };
6547     }
6548   }
6549
6550   jresult = result;
6551   return jresult;
6552 }
6553
6554
6555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6556   float jresult ;
6557   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6558   unsigned int arg2 ;
6559   float *result = 0 ;
6560
6561   arg1 = (Dali::Vector3 *)jarg1;
6562   arg2 = (unsigned int)jarg2;
6563   {
6564     try {
6565       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6566     } catch (std::out_of_range& e) {
6567       {
6568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (std::exception& e) {
6571       {
6572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6573       };
6574     } catch (Dali::DaliException e) {
6575       {
6576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6577       };
6578     } catch (...) {
6579       {
6580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6581       };
6582     }
6583   }
6584
6585   jresult = *result;
6586   return jresult;
6587 }
6588
6589
6590 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6591   float jresult ;
6592   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6593   Dali::Vector3 *arg2 = 0 ;
6594   float result;
6595
6596   arg1 = (Dali::Vector3 *)jarg1;
6597   arg2 = (Dali::Vector3 *)jarg2;
6598   if (!arg2) {
6599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6600     return 0;
6601   }
6602   {
6603     try {
6604       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6605     } catch (std::out_of_range& e) {
6606       {
6607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6608       };
6609     } catch (std::exception& e) {
6610       {
6611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (Dali::DaliException e) {
6614       {
6615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6616       };
6617     } catch (...) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6620       };
6621     }
6622   }
6623
6624   jresult = result;
6625   return jresult;
6626 }
6627
6628
6629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6630   void * jresult ;
6631   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6632   Dali::Vector3 *arg2 = 0 ;
6633   Dali::Vector3 result;
6634
6635   arg1 = (Dali::Vector3 *)jarg1;
6636   arg2 = (Dali::Vector3 *)jarg2;
6637   if (!arg2) {
6638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6639     return 0;
6640   }
6641   {
6642     try {
6643       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6644     } catch (std::out_of_range& e) {
6645       {
6646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6647       };
6648     } catch (std::exception& e) {
6649       {
6650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6651       };
6652     } catch (Dali::DaliException e) {
6653       {
6654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6655       };
6656     } catch (...) {
6657       {
6658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6659       };
6660     }
6661   }
6662
6663   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6664   return jresult;
6665 }
6666
6667
6668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6669   float jresult ;
6670   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6671   float result;
6672
6673   arg1 = (Dali::Vector3 *)jarg1;
6674   {
6675     try {
6676       result = (float)((Dali::Vector3 const *)arg1)->Length();
6677     } catch (std::out_of_range& e) {
6678       {
6679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6680       };
6681     } catch (std::exception& e) {
6682       {
6683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (Dali::DaliException e) {
6686       {
6687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6688       };
6689     } catch (...) {
6690       {
6691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6692       };
6693     }
6694   }
6695
6696   jresult = result;
6697   return jresult;
6698 }
6699
6700
6701 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6702   float jresult ;
6703   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6704   float result;
6705
6706   arg1 = (Dali::Vector3 *)jarg1;
6707   {
6708     try {
6709       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6710     } catch (std::out_of_range& e) {
6711       {
6712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6713       };
6714     } catch (std::exception& e) {
6715       {
6716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (Dali::DaliException e) {
6719       {
6720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6721       };
6722     } catch (...) {
6723       {
6724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6725       };
6726     }
6727   }
6728
6729   jresult = result;
6730   return jresult;
6731 }
6732
6733
6734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6735   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6736
6737   arg1 = (Dali::Vector3 *)jarg1;
6738   {
6739     try {
6740       (arg1)->Normalize();
6741     } catch (std::out_of_range& e) {
6742       {
6743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6744       };
6745     } catch (std::exception& e) {
6746       {
6747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6748       };
6749     } catch (Dali::DaliException e) {
6750       {
6751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6756       };
6757     }
6758   }
6759
6760 }
6761
6762
6763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6764   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6765   Dali::Vector3 *arg2 = 0 ;
6766   Dali::Vector3 *arg3 = 0 ;
6767
6768   arg1 = (Dali::Vector3 *)jarg1;
6769   arg2 = (Dali::Vector3 *)jarg2;
6770   if (!arg2) {
6771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6772     return ;
6773   }
6774   arg3 = (Dali::Vector3 *)jarg3;
6775   if (!arg3) {
6776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6777     return ;
6778   }
6779   {
6780     try {
6781       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6782     } catch (std::out_of_range& e) {
6783       {
6784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6785       };
6786     } catch (std::exception& e) {
6787       {
6788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6789       };
6790     } catch (Dali::DaliException e) {
6791       {
6792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6793       };
6794     } catch (...) {
6795       {
6796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6797       };
6798     }
6799   }
6800
6801 }
6802
6803
6804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6805   void * jresult ;
6806   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6807   float *result = 0 ;
6808
6809   arg1 = (Dali::Vector3 *)jarg1;
6810   {
6811     try {
6812       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6813     } catch (std::out_of_range& e) {
6814       {
6815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6816       };
6817     } catch (std::exception& e) {
6818       {
6819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (Dali::DaliException e) {
6822       {
6823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6824       };
6825     } catch (...) {
6826       {
6827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6828       };
6829     }
6830   }
6831
6832   jresult = (void *)result;
6833   return jresult;
6834 }
6835
6836
6837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6838   void * jresult ;
6839   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6840   Dali::Vector2 *result = 0 ;
6841
6842   arg1 = (Dali::Vector3 *)jarg1;
6843   {
6844     try {
6845       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6846     } catch (std::out_of_range& e) {
6847       {
6848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6849       };
6850     } catch (std::exception& e) {
6851       {
6852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6853       };
6854     } catch (Dali::DaliException e) {
6855       {
6856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6857       };
6858     } catch (...) {
6859       {
6860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6861       };
6862     }
6863   }
6864
6865   jresult = (void *)result;
6866   return jresult;
6867 }
6868
6869
6870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6871   void * jresult ;
6872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6873   Dali::Vector2 *result = 0 ;
6874
6875   arg1 = (Dali::Vector3 *)jarg1;
6876   {
6877     try {
6878       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6879     } catch (std::out_of_range& e) {
6880       {
6881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6882       };
6883     } catch (std::exception& e) {
6884       {
6885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6886       };
6887     } catch (Dali::DaliException e) {
6888       {
6889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6890       };
6891     } catch (...) {
6892       {
6893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6894       };
6895     }
6896   }
6897
6898   jresult = (void *)result;
6899   return jresult;
6900 }
6901
6902
6903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6904   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6905   float arg2 ;
6906
6907   arg1 = (Dali::Vector3 *)jarg1;
6908   arg2 = (float)jarg2;
6909   if (arg1) (arg1)->x = arg2;
6910 }
6911
6912
6913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6914   float jresult ;
6915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6916   float result;
6917
6918   arg1 = (Dali::Vector3 *)jarg1;
6919   result = (float) ((arg1)->x);
6920   jresult = result;
6921   return jresult;
6922 }
6923
6924
6925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6927   float arg2 ;
6928
6929   arg1 = (Dali::Vector3 *)jarg1;
6930   arg2 = (float)jarg2;
6931   if (arg1) (arg1)->width = arg2;
6932 }
6933
6934
6935 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6936   float jresult ;
6937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6938   float result;
6939
6940   arg1 = (Dali::Vector3 *)jarg1;
6941   result = (float) ((arg1)->width);
6942   jresult = result;
6943   return jresult;
6944 }
6945
6946
6947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6948   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6949   float arg2 ;
6950
6951   arg1 = (Dali::Vector3 *)jarg1;
6952   arg2 = (float)jarg2;
6953   if (arg1) (arg1)->r = arg2;
6954 }
6955
6956
6957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6958   float jresult ;
6959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6960   float result;
6961
6962   arg1 = (Dali::Vector3 *)jarg1;
6963   result = (float) ((arg1)->r);
6964   jresult = result;
6965   return jresult;
6966 }
6967
6968
6969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6970   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6971   float arg2 ;
6972
6973   arg1 = (Dali::Vector3 *)jarg1;
6974   arg2 = (float)jarg2;
6975   if (arg1) (arg1)->y = arg2;
6976 }
6977
6978
6979 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6980   float jresult ;
6981   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6982   float result;
6983
6984   arg1 = (Dali::Vector3 *)jarg1;
6985   result = (float) ((arg1)->y);
6986   jresult = result;
6987   return jresult;
6988 }
6989
6990
6991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6992   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6993   float arg2 ;
6994
6995   arg1 = (Dali::Vector3 *)jarg1;
6996   arg2 = (float)jarg2;
6997   if (arg1) (arg1)->height = arg2;
6998 }
6999
7000
7001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7002   float jresult ;
7003   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7004   float result;
7005
7006   arg1 = (Dali::Vector3 *)jarg1;
7007   result = (float) ((arg1)->height);
7008   jresult = result;
7009   return jresult;
7010 }
7011
7012
7013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7014   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7015   float arg2 ;
7016
7017   arg1 = (Dali::Vector3 *)jarg1;
7018   arg2 = (float)jarg2;
7019   if (arg1) (arg1)->g = arg2;
7020 }
7021
7022
7023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7024   float jresult ;
7025   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7026   float result;
7027
7028   arg1 = (Dali::Vector3 *)jarg1;
7029   result = (float) ((arg1)->g);
7030   jresult = result;
7031   return jresult;
7032 }
7033
7034
7035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7037   float arg2 ;
7038
7039   arg1 = (Dali::Vector3 *)jarg1;
7040   arg2 = (float)jarg2;
7041   if (arg1) (arg1)->z = arg2;
7042 }
7043
7044
7045 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7046   float jresult ;
7047   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7048   float result;
7049
7050   arg1 = (Dali::Vector3 *)jarg1;
7051   result = (float) ((arg1)->z);
7052   jresult = result;
7053   return jresult;
7054 }
7055
7056
7057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7058   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7059   float arg2 ;
7060
7061   arg1 = (Dali::Vector3 *)jarg1;
7062   arg2 = (float)jarg2;
7063   if (arg1) (arg1)->depth = arg2;
7064 }
7065
7066
7067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7068   float jresult ;
7069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7070   float result;
7071
7072   arg1 = (Dali::Vector3 *)jarg1;
7073   result = (float) ((arg1)->depth);
7074   jresult = result;
7075   return jresult;
7076 }
7077
7078
7079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7081   float arg2 ;
7082
7083   arg1 = (Dali::Vector3 *)jarg1;
7084   arg2 = (float)jarg2;
7085   if (arg1) (arg1)->b = arg2;
7086 }
7087
7088
7089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7090   float jresult ;
7091   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7092   float result;
7093
7094   arg1 = (Dali::Vector3 *)jarg1;
7095   result = (float) ((arg1)->b);
7096   jresult = result;
7097   return jresult;
7098 }
7099
7100
7101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7103
7104   arg1 = (Dali::Vector3 *)jarg1;
7105   {
7106     try {
7107       delete arg1;
7108     } catch (std::out_of_range& e) {
7109       {
7110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7111       };
7112     } catch (std::exception& e) {
7113       {
7114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7115       };
7116     } catch (Dali::DaliException e) {
7117       {
7118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7119       };
7120     } catch (...) {
7121       {
7122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7123       };
7124     }
7125   }
7126
7127 }
7128
7129
7130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7131   void * jresult ;
7132   Dali::Vector3 *arg1 = 0 ;
7133   Dali::Vector3 *arg2 = 0 ;
7134   Dali::Vector3 result;
7135
7136   arg1 = (Dali::Vector3 *)jarg1;
7137   if (!arg1) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7139     return 0;
7140   }
7141   arg2 = (Dali::Vector3 *)jarg2;
7142   if (!arg2) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   {
7147     try {
7148       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7149     } catch (std::out_of_range& e) {
7150       {
7151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7152       };
7153     } catch (std::exception& e) {
7154       {
7155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (Dali::DaliException e) {
7158       {
7159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7160       };
7161     } catch (...) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7164       };
7165     }
7166   }
7167
7168   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7169   return jresult;
7170 }
7171
7172
7173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7174   void * jresult ;
7175   Dali::Vector3 *arg1 = 0 ;
7176   Dali::Vector3 *arg2 = 0 ;
7177   Dali::Vector3 result;
7178
7179   arg1 = (Dali::Vector3 *)jarg1;
7180   if (!arg1) {
7181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7182     return 0;
7183   }
7184   arg2 = (Dali::Vector3 *)jarg2;
7185   if (!arg2) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   {
7190     try {
7191       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7192     } catch (std::out_of_range& e) {
7193       {
7194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7195       };
7196     } catch (std::exception& e) {
7197       {
7198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7199       };
7200     } catch (Dali::DaliException e) {
7201       {
7202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7203       };
7204     } catch (...) {
7205       {
7206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7207       };
7208     }
7209   }
7210
7211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7212   return jresult;
7213 }
7214
7215
7216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7217   void * jresult ;
7218   Dali::Vector3 *arg1 = 0 ;
7219   float *arg2 = 0 ;
7220   float *arg3 = 0 ;
7221   float temp2 ;
7222   float temp3 ;
7223   Dali::Vector3 result;
7224
7225   arg1 = (Dali::Vector3 *)jarg1;
7226   if (!arg1) {
7227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7228     return 0;
7229   }
7230   temp2 = (float)jarg2;
7231   arg2 = &temp2;
7232   temp3 = (float)jarg3;
7233   arg3 = &temp3;
7234   {
7235     try {
7236       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7237     } catch (std::out_of_range& e) {
7238       {
7239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7240       };
7241     } catch (std::exception& e) {
7242       {
7243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7244       };
7245     } catch (Dali::DaliException e) {
7246       {
7247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7248       };
7249     } catch (...) {
7250       {
7251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7252       };
7253     }
7254   }
7255
7256   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7257   return jresult;
7258 }
7259
7260
7261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7262   void * jresult ;
7263   Dali::Vector4 *result = 0 ;
7264
7265   {
7266     try {
7267       result = (Dali::Vector4 *)new Dali::Vector4();
7268     } catch (std::out_of_range& e) {
7269       {
7270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (std::exception& e) {
7273       {
7274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (Dali::DaliException e) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7279       };
7280     } catch (...) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7283       };
7284     }
7285   }
7286
7287   jresult = (void *)result;
7288   return jresult;
7289 }
7290
7291
7292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7293   void * jresult ;
7294   float arg1 ;
7295   float arg2 ;
7296   float arg3 ;
7297   float arg4 ;
7298   Dali::Vector4 *result = 0 ;
7299
7300   arg1 = (float)jarg1;
7301   arg2 = (float)jarg2;
7302   arg3 = (float)jarg3;
7303   arg4 = (float)jarg4;
7304   {
7305     try {
7306       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7307     } catch (std::out_of_range& e) {
7308       {
7309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7310       };
7311     } catch (std::exception& e) {
7312       {
7313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7314       };
7315     } catch (Dali::DaliException e) {
7316       {
7317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7318       };
7319     } catch (...) {
7320       {
7321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7322       };
7323     }
7324   }
7325
7326   jresult = (void *)result;
7327   return jresult;
7328 }
7329
7330
7331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7332   void * jresult ;
7333   float *arg1 = (float *) 0 ;
7334   Dali::Vector4 *result = 0 ;
7335
7336   arg1 = jarg1;
7337   {
7338     try {
7339       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7340     } catch (std::out_of_range& e) {
7341       {
7342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7343       };
7344     } catch (std::exception& e) {
7345       {
7346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7347       };
7348     } catch (Dali::DaliException e) {
7349       {
7350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7351       };
7352     } catch (...) {
7353       {
7354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7355       };
7356     }
7357   }
7358
7359   jresult = (void *)result;
7360
7361
7362   return jresult;
7363 }
7364
7365
7366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7367   void * jresult ;
7368   Dali::Vector2 *arg1 = 0 ;
7369   Dali::Vector4 *result = 0 ;
7370
7371   arg1 = (Dali::Vector2 *)jarg1;
7372   if (!arg1) {
7373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7374     return 0;
7375   }
7376   {
7377     try {
7378       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7379     } catch (std::out_of_range& e) {
7380       {
7381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (std::exception& e) {
7384       {
7385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7386       };
7387     } catch (Dali::DaliException e) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7390       };
7391     } catch (...) {
7392       {
7393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7394       };
7395     }
7396   }
7397
7398   jresult = (void *)result;
7399   return jresult;
7400 }
7401
7402
7403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7404   void * jresult ;
7405   Dali::Vector3 *arg1 = 0 ;
7406   Dali::Vector4 *result = 0 ;
7407
7408   arg1 = (Dali::Vector3 *)jarg1;
7409   if (!arg1) {
7410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7411     return 0;
7412   }
7413   {
7414     try {
7415       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7416     } catch (std::out_of_range& e) {
7417       {
7418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7419       };
7420     } catch (std::exception& e) {
7421       {
7422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7423       };
7424     } catch (Dali::DaliException e) {
7425       {
7426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7427       };
7428     } catch (...) {
7429       {
7430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7431       };
7432     }
7433   }
7434
7435   jresult = (void *)result;
7436   return jresult;
7437 }
7438
7439
7440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7441   void * jresult ;
7442   Dali::Vector4 *result = 0 ;
7443
7444   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7445   jresult = (void *)result;
7446   return jresult;
7447 }
7448
7449
7450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7451   void * jresult ;
7452   Dali::Vector4 *result = 0 ;
7453
7454   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7455   jresult = (void *)result;
7456   return jresult;
7457 }
7458
7459
7460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7461   void * jresult ;
7462   Dali::Vector4 *result = 0 ;
7463
7464   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7465   jresult = (void *)result;
7466   return jresult;
7467 }
7468
7469
7470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7471   void * jresult ;
7472   Dali::Vector4 *result = 0 ;
7473
7474   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7475   jresult = (void *)result;
7476   return jresult;
7477 }
7478
7479
7480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7481   void * jresult ;
7482   Dali::Vector4 *result = 0 ;
7483
7484   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7485   jresult = (void *)result;
7486   return jresult;
7487 }
7488
7489
7490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7491   void * jresult ;
7492   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7493   float *arg2 = (float *) 0 ;
7494   Dali::Vector4 *result = 0 ;
7495
7496   arg1 = (Dali::Vector4 *)jarg1;
7497   arg2 = jarg2;
7498   {
7499     try {
7500       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7501     } catch (std::out_of_range& e) {
7502       {
7503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7504       };
7505     } catch (std::exception& e) {
7506       {
7507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7508       };
7509     } catch (Dali::DaliException e) {
7510       {
7511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7512       };
7513     } catch (...) {
7514       {
7515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7516       };
7517     }
7518   }
7519
7520   jresult = (void *)result;
7521
7522
7523   return jresult;
7524 }
7525
7526
7527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7528   void * jresult ;
7529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7530   Dali::Vector2 *arg2 = 0 ;
7531   Dali::Vector4 *result = 0 ;
7532
7533   arg1 = (Dali::Vector4 *)jarg1;
7534   arg2 = (Dali::Vector2 *)jarg2;
7535   if (!arg2) {
7536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7537     return 0;
7538   }
7539   {
7540     try {
7541       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7542     } catch (std::out_of_range& e) {
7543       {
7544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (std::exception& e) {
7547       {
7548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (Dali::DaliException e) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7553       };
7554     } catch (...) {
7555       {
7556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7557       };
7558     }
7559   }
7560
7561   jresult = (void *)result;
7562   return jresult;
7563 }
7564
7565
7566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7567   void * jresult ;
7568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7569   Dali::Vector3 *arg2 = 0 ;
7570   Dali::Vector4 *result = 0 ;
7571
7572   arg1 = (Dali::Vector4 *)jarg1;
7573   arg2 = (Dali::Vector3 *)jarg2;
7574   if (!arg2) {
7575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7576     return 0;
7577   }
7578   {
7579     try {
7580       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7581     } catch (std::out_of_range& e) {
7582       {
7583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (std::exception& e) {
7586       {
7587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7588       };
7589     } catch (Dali::DaliException e) {
7590       {
7591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7592       };
7593     } catch (...) {
7594       {
7595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7596       };
7597     }
7598   }
7599
7600   jresult = (void *)result;
7601   return jresult;
7602 }
7603
7604
7605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7606   void * jresult ;
7607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7608   Dali::Vector4 *arg2 = 0 ;
7609   Dali::Vector4 result;
7610
7611   arg1 = (Dali::Vector4 *)jarg1;
7612   arg2 = (Dali::Vector4 *)jarg2;
7613   if (!arg2) {
7614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7615     return 0;
7616   }
7617   {
7618     try {
7619       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7620     } catch (std::out_of_range& e) {
7621       {
7622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7623       };
7624     } catch (std::exception& e) {
7625       {
7626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7627       };
7628     } catch (Dali::DaliException e) {
7629       {
7630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7631       };
7632     } catch (...) {
7633       {
7634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7635       };
7636     }
7637   }
7638
7639   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7640   return jresult;
7641 }
7642
7643
7644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7645   void * jresult ;
7646   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7647   Dali::Vector4 *arg2 = 0 ;
7648   Dali::Vector4 *result = 0 ;
7649
7650   arg1 = (Dali::Vector4 *)jarg1;
7651   arg2 = (Dali::Vector4 *)jarg2;
7652   if (!arg2) {
7653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7654     return 0;
7655   }
7656   {
7657     try {
7658       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7659     } catch (std::out_of_range& e) {
7660       {
7661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (std::exception& e) {
7664       {
7665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (Dali::DaliException e) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7670       };
7671     } catch (...) {
7672       {
7673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7674       };
7675     }
7676   }
7677
7678   jresult = (void *)result;
7679   return jresult;
7680 }
7681
7682
7683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7684   void * jresult ;
7685   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7686   Dali::Vector4 *arg2 = 0 ;
7687   Dali::Vector4 result;
7688
7689   arg1 = (Dali::Vector4 *)jarg1;
7690   arg2 = (Dali::Vector4 *)jarg2;
7691   if (!arg2) {
7692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7693     return 0;
7694   }
7695   {
7696     try {
7697       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7698     } catch (std::out_of_range& e) {
7699       {
7700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7701       };
7702     } catch (std::exception& e) {
7703       {
7704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7705       };
7706     } catch (Dali::DaliException e) {
7707       {
7708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7709       };
7710     } catch (...) {
7711       {
7712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7713       };
7714     }
7715   }
7716
7717   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7718   return jresult;
7719 }
7720
7721
7722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7723   void * jresult ;
7724   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7725   Dali::Vector4 *arg2 = 0 ;
7726   Dali::Vector4 *result = 0 ;
7727
7728   arg1 = (Dali::Vector4 *)jarg1;
7729   arg2 = (Dali::Vector4 *)jarg2;
7730   if (!arg2) {
7731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7732     return 0;
7733   }
7734   {
7735     try {
7736       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7737     } catch (std::out_of_range& e) {
7738       {
7739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7740       };
7741     } catch (std::exception& e) {
7742       {
7743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7744       };
7745     } catch (Dali::DaliException e) {
7746       {
7747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7748       };
7749     } catch (...) {
7750       {
7751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7752       };
7753     }
7754   }
7755
7756   jresult = (void *)result;
7757   return jresult;
7758 }
7759
7760
7761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7762   void * jresult ;
7763   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7764   Dali::Vector4 *arg2 = 0 ;
7765   Dali::Vector4 result;
7766
7767   arg1 = (Dali::Vector4 *)jarg1;
7768   arg2 = (Dali::Vector4 *)jarg2;
7769   if (!arg2) {
7770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7771     return 0;
7772   }
7773   {
7774     try {
7775       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7776     } catch (std::out_of_range& e) {
7777       {
7778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7779       };
7780     } catch (std::exception& e) {
7781       {
7782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7783       };
7784     } catch (Dali::DaliException e) {
7785       {
7786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7787       };
7788     } catch (...) {
7789       {
7790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7791       };
7792     }
7793   }
7794
7795   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7796   return jresult;
7797 }
7798
7799
7800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7801   void * jresult ;
7802   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7803   float arg2 ;
7804   Dali::Vector4 result;
7805
7806   arg1 = (Dali::Vector4 *)jarg1;
7807   arg2 = (float)jarg2;
7808   {
7809     try {
7810       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7811     } catch (std::out_of_range& e) {
7812       {
7813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7814       };
7815     } catch (std::exception& e) {
7816       {
7817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7818       };
7819     } catch (Dali::DaliException e) {
7820       {
7821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7822       };
7823     } catch (...) {
7824       {
7825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7826       };
7827     }
7828   }
7829
7830   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7831   return jresult;
7832 }
7833
7834
7835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7836   void * jresult ;
7837   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7838   Dali::Vector4 *arg2 = 0 ;
7839   Dali::Vector4 *result = 0 ;
7840
7841   arg1 = (Dali::Vector4 *)jarg1;
7842   arg2 = (Dali::Vector4 *)jarg2;
7843   if (!arg2) {
7844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7845     return 0;
7846   }
7847   {
7848     try {
7849       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7850     } catch (std::out_of_range& e) {
7851       {
7852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7853       };
7854     } catch (std::exception& e) {
7855       {
7856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7857       };
7858     } catch (Dali::DaliException e) {
7859       {
7860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7861       };
7862     } catch (...) {
7863       {
7864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7865       };
7866     }
7867   }
7868
7869   jresult = (void *)result;
7870   return jresult;
7871 }
7872
7873
7874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7875   void * jresult ;
7876   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7877   float arg2 ;
7878   Dali::Vector4 *result = 0 ;
7879
7880   arg1 = (Dali::Vector4 *)jarg1;
7881   arg2 = (float)jarg2;
7882   {
7883     try {
7884       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7885     } catch (std::out_of_range& e) {
7886       {
7887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (std::exception& e) {
7890       {
7891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (Dali::DaliException e) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7896       };
7897     } catch (...) {
7898       {
7899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7900       };
7901     }
7902   }
7903
7904   jresult = (void *)result;
7905   return jresult;
7906 }
7907
7908
7909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7910   void * jresult ;
7911   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7912   Dali::Vector4 *arg2 = 0 ;
7913   Dali::Vector4 result;
7914
7915   arg1 = (Dali::Vector4 *)jarg1;
7916   arg2 = (Dali::Vector4 *)jarg2;
7917   if (!arg2) {
7918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7919     return 0;
7920   }
7921   {
7922     try {
7923       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7924     } catch (std::out_of_range& e) {
7925       {
7926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7927       };
7928     } catch (std::exception& e) {
7929       {
7930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7931       };
7932     } catch (Dali::DaliException e) {
7933       {
7934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7935       };
7936     } catch (...) {
7937       {
7938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7939       };
7940     }
7941   }
7942
7943   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7944   return jresult;
7945 }
7946
7947
7948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7949   void * jresult ;
7950   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7951   float arg2 ;
7952   Dali::Vector4 result;
7953
7954   arg1 = (Dali::Vector4 *)jarg1;
7955   arg2 = (float)jarg2;
7956   {
7957     try {
7958       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7959     } catch (std::out_of_range& e) {
7960       {
7961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7962       };
7963     } catch (std::exception& e) {
7964       {
7965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (Dali::DaliException e) {
7968       {
7969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7970       };
7971     } catch (...) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7974       };
7975     }
7976   }
7977
7978   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7979   return jresult;
7980 }
7981
7982
7983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7984   void * jresult ;
7985   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7986   Dali::Vector4 *arg2 = 0 ;
7987   Dali::Vector4 *result = 0 ;
7988
7989   arg1 = (Dali::Vector4 *)jarg1;
7990   arg2 = (Dali::Vector4 *)jarg2;
7991   if (!arg2) {
7992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7993     return 0;
7994   }
7995   {
7996     try {
7997       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7998     } catch (std::out_of_range& e) {
7999       {
8000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8001       };
8002     } catch (std::exception& e) {
8003       {
8004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8005       };
8006     } catch (Dali::DaliException e) {
8007       {
8008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8009       };
8010     } catch (...) {
8011       {
8012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8013       };
8014     }
8015   }
8016
8017   jresult = (void *)result;
8018   return jresult;
8019 }
8020
8021
8022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8023   void * jresult ;
8024   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8025   float arg2 ;
8026   Dali::Vector4 *result = 0 ;
8027
8028   arg1 = (Dali::Vector4 *)jarg1;
8029   arg2 = (float)jarg2;
8030   {
8031     try {
8032       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8033     } catch (std::out_of_range& e) {
8034       {
8035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8036       };
8037     } catch (std::exception& e) {
8038       {
8039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (Dali::DaliException e) {
8042       {
8043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8044       };
8045     } catch (...) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8048       };
8049     }
8050   }
8051
8052   jresult = (void *)result;
8053   return jresult;
8054 }
8055
8056
8057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8058   void * jresult ;
8059   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8060   Dali::Vector4 result;
8061
8062   arg1 = (Dali::Vector4 *)jarg1;
8063   {
8064     try {
8065       result = ((Dali::Vector4 const *)arg1)->operator -();
8066     } catch (std::out_of_range& e) {
8067       {
8068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (std::exception& e) {
8071       {
8072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (Dali::DaliException e) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8077       };
8078     } catch (...) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8081       };
8082     }
8083   }
8084
8085   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8086   return jresult;
8087 }
8088
8089
8090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8091   unsigned int jresult ;
8092   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8093   Dali::Vector4 *arg2 = 0 ;
8094   bool result;
8095
8096   arg1 = (Dali::Vector4 *)jarg1;
8097   arg2 = (Dali::Vector4 *)jarg2;
8098   if (!arg2) {
8099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8100     return 0;
8101   }
8102   {
8103     try {
8104       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8105     } catch (std::out_of_range& e) {
8106       {
8107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (std::exception& e) {
8110       {
8111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (Dali::DaliException e) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8116       };
8117     } catch (...) {
8118       {
8119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8120       };
8121     }
8122   }
8123
8124   jresult = result;
8125   return jresult;
8126 }
8127
8128
8129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8130   unsigned int jresult ;
8131   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8132   Dali::Vector4 *arg2 = 0 ;
8133   bool result;
8134
8135   arg1 = (Dali::Vector4 *)jarg1;
8136   arg2 = (Dali::Vector4 *)jarg2;
8137   if (!arg2) {
8138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8139     return 0;
8140   }
8141   {
8142     try {
8143       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8144     } catch (std::out_of_range& e) {
8145       {
8146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8147       };
8148     } catch (std::exception& e) {
8149       {
8150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8151       };
8152     } catch (Dali::DaliException e) {
8153       {
8154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8155       };
8156     } catch (...) {
8157       {
8158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8159       };
8160     }
8161   }
8162
8163   jresult = result;
8164   return jresult;
8165 }
8166
8167
8168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8169   float jresult ;
8170   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8171   unsigned int arg2 ;
8172   float *result = 0 ;
8173
8174   arg1 = (Dali::Vector4 *)jarg1;
8175   arg2 = (unsigned int)jarg2;
8176   {
8177     try {
8178       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8179     } catch (std::out_of_range& e) {
8180       {
8181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8182       };
8183     } catch (std::exception& e) {
8184       {
8185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (Dali::DaliException e) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8190       };
8191     } catch (...) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8194       };
8195     }
8196   }
8197
8198   jresult = *result;
8199   return jresult;
8200 }
8201
8202
8203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8204   float jresult ;
8205   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8206   Dali::Vector3 *arg2 = 0 ;
8207   float result;
8208
8209   arg1 = (Dali::Vector4 *)jarg1;
8210   arg2 = (Dali::Vector3 *)jarg2;
8211   if (!arg2) {
8212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8213     return 0;
8214   }
8215   {
8216     try {
8217       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8218     } catch (std::out_of_range& e) {
8219       {
8220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (std::exception& e) {
8223       {
8224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (Dali::DaliException e) {
8227       {
8228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8229       };
8230     } catch (...) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8233       };
8234     }
8235   }
8236
8237   jresult = result;
8238   return jresult;
8239 }
8240
8241
8242 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8243   float jresult ;
8244   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8245   Dali::Vector4 *arg2 = 0 ;
8246   float result;
8247
8248   arg1 = (Dali::Vector4 *)jarg1;
8249   arg2 = (Dali::Vector4 *)jarg2;
8250   if (!arg2) {
8251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8252     return 0;
8253   }
8254   {
8255     try {
8256       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8257     } catch (std::out_of_range& e) {
8258       {
8259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (std::exception& e) {
8262       {
8263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (Dali::DaliException e) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8268       };
8269     } catch (...) {
8270       {
8271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8272       };
8273     }
8274   }
8275
8276   jresult = result;
8277   return jresult;
8278 }
8279
8280
8281 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8282   float jresult ;
8283   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8284   Dali::Vector4 *arg2 = 0 ;
8285   float result;
8286
8287   arg1 = (Dali::Vector4 *)jarg1;
8288   arg2 = (Dali::Vector4 *)jarg2;
8289   if (!arg2) {
8290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8291     return 0;
8292   }
8293   {
8294     try {
8295       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8296     } catch (std::out_of_range& e) {
8297       {
8298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (std::exception& e) {
8301       {
8302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (Dali::DaliException e) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8307       };
8308     } catch (...) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8311       };
8312     }
8313   }
8314
8315   jresult = result;
8316   return jresult;
8317 }
8318
8319
8320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8321   void * jresult ;
8322   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8323   Dali::Vector4 *arg2 = 0 ;
8324   Dali::Vector4 result;
8325
8326   arg1 = (Dali::Vector4 *)jarg1;
8327   arg2 = (Dali::Vector4 *)jarg2;
8328   if (!arg2) {
8329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8330     return 0;
8331   }
8332   {
8333     try {
8334       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8335     } catch (std::out_of_range& e) {
8336       {
8337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8338       };
8339     } catch (std::exception& e) {
8340       {
8341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8342       };
8343     } catch (Dali::DaliException e) {
8344       {
8345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8346       };
8347     } catch (...) {
8348       {
8349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8350       };
8351     }
8352   }
8353
8354   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8355   return jresult;
8356 }
8357
8358
8359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8360   float jresult ;
8361   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8362   float result;
8363
8364   arg1 = (Dali::Vector4 *)jarg1;
8365   {
8366     try {
8367       result = (float)((Dali::Vector4 const *)arg1)->Length();
8368     } catch (std::out_of_range& e) {
8369       {
8370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8371       };
8372     } catch (std::exception& e) {
8373       {
8374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (Dali::DaliException e) {
8377       {
8378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8379       };
8380     } catch (...) {
8381       {
8382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8383       };
8384     }
8385   }
8386
8387   jresult = result;
8388   return jresult;
8389 }
8390
8391
8392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8393   float jresult ;
8394   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8395   float result;
8396
8397   arg1 = (Dali::Vector4 *)jarg1;
8398   {
8399     try {
8400       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8401     } catch (std::out_of_range& e) {
8402       {
8403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8404       };
8405     } catch (std::exception& e) {
8406       {
8407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8408       };
8409     } catch (Dali::DaliException e) {
8410       {
8411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8412       };
8413     } catch (...) {
8414       {
8415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8416       };
8417     }
8418   }
8419
8420   jresult = result;
8421   return jresult;
8422 }
8423
8424
8425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8426   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8427
8428   arg1 = (Dali::Vector4 *)jarg1;
8429   {
8430     try {
8431       (arg1)->Normalize();
8432     } catch (std::out_of_range& e) {
8433       {
8434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8435       };
8436     } catch (std::exception& e) {
8437       {
8438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8439       };
8440     } catch (Dali::DaliException e) {
8441       {
8442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8447       };
8448     }
8449   }
8450
8451 }
8452
8453
8454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8455   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8456   Dali::Vector4 *arg2 = 0 ;
8457   Dali::Vector4 *arg3 = 0 ;
8458
8459   arg1 = (Dali::Vector4 *)jarg1;
8460   arg2 = (Dali::Vector4 *)jarg2;
8461   if (!arg2) {
8462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8463     return ;
8464   }
8465   arg3 = (Dali::Vector4 *)jarg3;
8466   if (!arg3) {
8467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8468     return ;
8469   }
8470   {
8471     try {
8472       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8473     } catch (std::out_of_range& e) {
8474       {
8475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8476       };
8477     } catch (std::exception& e) {
8478       {
8479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8480       };
8481     } catch (Dali::DaliException e) {
8482       {
8483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8484       };
8485     } catch (...) {
8486       {
8487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8488       };
8489     }
8490   }
8491
8492 }
8493
8494
8495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8496   void * jresult ;
8497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8498   float *result = 0 ;
8499
8500   arg1 = (Dali::Vector4 *)jarg1;
8501   {
8502     try {
8503       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8504     } catch (std::out_of_range& e) {
8505       {
8506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8507       };
8508     } catch (std::exception& e) {
8509       {
8510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (Dali::DaliException e) {
8513       {
8514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8515       };
8516     } catch (...) {
8517       {
8518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8519       };
8520     }
8521   }
8522
8523   jresult = (void *)result;
8524   return jresult;
8525 }
8526
8527
8528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8529   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8530   float arg2 ;
8531
8532   arg1 = (Dali::Vector4 *)jarg1;
8533   arg2 = (float)jarg2;
8534   if (arg1) (arg1)->x = arg2;
8535 }
8536
8537
8538 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8539   float jresult ;
8540   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8541   float result;
8542
8543   arg1 = (Dali::Vector4 *)jarg1;
8544   result = (float) ((arg1)->x);
8545   jresult = result;
8546   return jresult;
8547 }
8548
8549
8550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8552   float arg2 ;
8553
8554   arg1 = (Dali::Vector4 *)jarg1;
8555   arg2 = (float)jarg2;
8556   if (arg1) (arg1)->r = arg2;
8557 }
8558
8559
8560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8561   float jresult ;
8562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8563   float result;
8564
8565   arg1 = (Dali::Vector4 *)jarg1;
8566   result = (float) ((arg1)->r);
8567   jresult = result;
8568   return jresult;
8569 }
8570
8571
8572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8574   float arg2 ;
8575
8576   arg1 = (Dali::Vector4 *)jarg1;
8577   arg2 = (float)jarg2;
8578   if (arg1) (arg1)->s = arg2;
8579 }
8580
8581
8582 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8583   float jresult ;
8584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8585   float result;
8586
8587   arg1 = (Dali::Vector4 *)jarg1;
8588   result = (float) ((arg1)->s);
8589   jresult = result;
8590   return jresult;
8591 }
8592
8593
8594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8595   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8596   float arg2 ;
8597
8598   arg1 = (Dali::Vector4 *)jarg1;
8599   arg2 = (float)jarg2;
8600   if (arg1) (arg1)->y = arg2;
8601 }
8602
8603
8604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8605   float jresult ;
8606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8607   float result;
8608
8609   arg1 = (Dali::Vector4 *)jarg1;
8610   result = (float) ((arg1)->y);
8611   jresult = result;
8612   return jresult;
8613 }
8614
8615
8616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8617   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8618   float arg2 ;
8619
8620   arg1 = (Dali::Vector4 *)jarg1;
8621   arg2 = (float)jarg2;
8622   if (arg1) (arg1)->g = arg2;
8623 }
8624
8625
8626 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8627   float jresult ;
8628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8629   float result;
8630
8631   arg1 = (Dali::Vector4 *)jarg1;
8632   result = (float) ((arg1)->g);
8633   jresult = result;
8634   return jresult;
8635 }
8636
8637
8638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8639   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8640   float arg2 ;
8641
8642   arg1 = (Dali::Vector4 *)jarg1;
8643   arg2 = (float)jarg2;
8644   if (arg1) (arg1)->t = arg2;
8645 }
8646
8647
8648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8649   float jresult ;
8650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8651   float result;
8652
8653   arg1 = (Dali::Vector4 *)jarg1;
8654   result = (float) ((arg1)->t);
8655   jresult = result;
8656   return jresult;
8657 }
8658
8659
8660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8661   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8662   float arg2 ;
8663
8664   arg1 = (Dali::Vector4 *)jarg1;
8665   arg2 = (float)jarg2;
8666   if (arg1) (arg1)->z = arg2;
8667 }
8668
8669
8670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8671   float jresult ;
8672   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8673   float result;
8674
8675   arg1 = (Dali::Vector4 *)jarg1;
8676   result = (float) ((arg1)->z);
8677   jresult = result;
8678   return jresult;
8679 }
8680
8681
8682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8684   float arg2 ;
8685
8686   arg1 = (Dali::Vector4 *)jarg1;
8687   arg2 = (float)jarg2;
8688   if (arg1) (arg1)->b = arg2;
8689 }
8690
8691
8692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8693   float jresult ;
8694   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8695   float result;
8696
8697   arg1 = (Dali::Vector4 *)jarg1;
8698   result = (float) ((arg1)->b);
8699   jresult = result;
8700   return jresult;
8701 }
8702
8703
8704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8705   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8706   float arg2 ;
8707
8708   arg1 = (Dali::Vector4 *)jarg1;
8709   arg2 = (float)jarg2;
8710   if (arg1) (arg1)->p = arg2;
8711 }
8712
8713
8714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8715   float jresult ;
8716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8717   float result;
8718
8719   arg1 = (Dali::Vector4 *)jarg1;
8720   result = (float) ((arg1)->p);
8721   jresult = result;
8722   return jresult;
8723 }
8724
8725
8726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8728   float arg2 ;
8729
8730   arg1 = (Dali::Vector4 *)jarg1;
8731   arg2 = (float)jarg2;
8732   if (arg1) (arg1)->w = arg2;
8733 }
8734
8735
8736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8737   float jresult ;
8738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8739   float result;
8740
8741   arg1 = (Dali::Vector4 *)jarg1;
8742   result = (float) ((arg1)->w);
8743   jresult = result;
8744   return jresult;
8745 }
8746
8747
8748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8750   float arg2 ;
8751
8752   arg1 = (Dali::Vector4 *)jarg1;
8753   arg2 = (float)jarg2;
8754   if (arg1) (arg1)->a = arg2;
8755 }
8756
8757
8758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8759   float jresult ;
8760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8761   float result;
8762
8763   arg1 = (Dali::Vector4 *)jarg1;
8764   result = (float) ((arg1)->a);
8765   jresult = result;
8766   return jresult;
8767 }
8768
8769
8770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8772   float arg2 ;
8773
8774   arg1 = (Dali::Vector4 *)jarg1;
8775   arg2 = (float)jarg2;
8776   if (arg1) (arg1)->q = arg2;
8777 }
8778
8779
8780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8781   float jresult ;
8782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8783   float result;
8784
8785   arg1 = (Dali::Vector4 *)jarg1;
8786   result = (float) ((arg1)->q);
8787   jresult = result;
8788   return jresult;
8789 }
8790
8791
8792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8793   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8794
8795   arg1 = (Dali::Vector4 *)jarg1;
8796   {
8797     try {
8798       delete arg1;
8799     } catch (std::out_of_range& e) {
8800       {
8801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8802       };
8803     } catch (std::exception& e) {
8804       {
8805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8806       };
8807     } catch (Dali::DaliException e) {
8808       {
8809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8810       };
8811     } catch (...) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8814       };
8815     }
8816   }
8817
8818 }
8819
8820
8821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8822   void * jresult ;
8823   Dali::Vector4 *arg1 = 0 ;
8824   Dali::Vector4 *arg2 = 0 ;
8825   Dali::Vector4 result;
8826
8827   arg1 = (Dali::Vector4 *)jarg1;
8828   if (!arg1) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8830     return 0;
8831   }
8832   arg2 = (Dali::Vector4 *)jarg2;
8833   if (!arg2) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   {
8838     try {
8839       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8840     } catch (std::out_of_range& e) {
8841       {
8842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8843       };
8844     } catch (std::exception& e) {
8845       {
8846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (Dali::DaliException e) {
8849       {
8850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8851       };
8852     } catch (...) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8855       };
8856     }
8857   }
8858
8859   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8860   return jresult;
8861 }
8862
8863
8864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8865   void * jresult ;
8866   Dali::Vector4 *arg1 = 0 ;
8867   Dali::Vector4 *arg2 = 0 ;
8868   Dali::Vector4 result;
8869
8870   arg1 = (Dali::Vector4 *)jarg1;
8871   if (!arg1) {
8872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8873     return 0;
8874   }
8875   arg2 = (Dali::Vector4 *)jarg2;
8876   if (!arg2) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   {
8881     try {
8882       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8883     } catch (std::out_of_range& e) {
8884       {
8885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8886       };
8887     } catch (std::exception& e) {
8888       {
8889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (Dali::DaliException e) {
8892       {
8893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8894       };
8895     } catch (...) {
8896       {
8897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8898       };
8899     }
8900   }
8901
8902   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8903   return jresult;
8904 }
8905
8906
8907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8908   void * jresult ;
8909   Dali::Vector4 *arg1 = 0 ;
8910   float *arg2 = 0 ;
8911   float *arg3 = 0 ;
8912   float temp2 ;
8913   float temp3 ;
8914   Dali::Vector4 result;
8915
8916   arg1 = (Dali::Vector4 *)jarg1;
8917   if (!arg1) {
8918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8919     return 0;
8920   }
8921   temp2 = (float)jarg2;
8922   arg2 = &temp2;
8923   temp3 = (float)jarg3;
8924   arg3 = &temp3;
8925   {
8926     try {
8927       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8928     } catch (std::out_of_range& e) {
8929       {
8930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8931       };
8932     } catch (std::exception& e) {
8933       {
8934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8935       };
8936     } catch (Dali::DaliException e) {
8937       {
8938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8939       };
8940     } catch (...) {
8941       {
8942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8943       };
8944     }
8945   }
8946
8947   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8948   return jresult;
8949 }
8950
8951
8952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8953   void * jresult ;
8954   Dali::Uint16Pair *result = 0 ;
8955
8956   {
8957     try {
8958       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8959     } catch (std::out_of_range& e) {
8960       {
8961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8962       };
8963     } catch (std::exception& e) {
8964       {
8965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8966       };
8967     } catch (Dali::DaliException e) {
8968       {
8969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8970       };
8971     } catch (...) {
8972       {
8973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8974       };
8975     }
8976   }
8977
8978   jresult = (void *)result;
8979   return jresult;
8980 }
8981
8982
8983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8984   void * jresult ;
8985   uint32_t arg1 ;
8986   uint32_t arg2 ;
8987   Dali::Uint16Pair *result = 0 ;
8988
8989   arg1 = (uint32_t)jarg1;
8990   arg2 = (uint32_t)jarg2;
8991   {
8992     try {
8993       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8994     } catch (std::out_of_range& e) {
8995       {
8996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8997       };
8998     } catch (std::exception& e) {
8999       {
9000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (Dali::DaliException e) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9005       };
9006     } catch (...) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9009       };
9010     }
9011   }
9012
9013   jresult = (void *)result;
9014   return jresult;
9015 }
9016
9017
9018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9019   void * jresult ;
9020   Dali::Uint16Pair *arg1 = 0 ;
9021   Dali::Uint16Pair *result = 0 ;
9022
9023   arg1 = (Dali::Uint16Pair *)jarg1;
9024   if (!arg1) {
9025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9026     return 0;
9027   }
9028   {
9029     try {
9030       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9031     } catch (std::out_of_range& e) {
9032       {
9033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9034       };
9035     } catch (std::exception& e) {
9036       {
9037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9038       };
9039     } catch (Dali::DaliException e) {
9040       {
9041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9042       };
9043     } catch (...) {
9044       {
9045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9046       };
9047     }
9048   }
9049
9050   jresult = (void *)result;
9051   return jresult;
9052 }
9053
9054
9055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9056   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9057   uint16_t arg2 ;
9058
9059   arg1 = (Dali::Uint16Pair *)jarg1;
9060   arg2 = (uint16_t)jarg2;
9061   {
9062     try {
9063       (arg1)->SetWidth(arg2);
9064     } catch (std::out_of_range& e) {
9065       {
9066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9067       };
9068     } catch (std::exception& e) {
9069       {
9070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9071       };
9072     } catch (Dali::DaliException e) {
9073       {
9074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9075       };
9076     } catch (...) {
9077       {
9078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9079       };
9080     }
9081   }
9082
9083 }
9084
9085
9086 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9087   unsigned short jresult ;
9088   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9089   uint16_t result;
9090
9091   arg1 = (Dali::Uint16Pair *)jarg1;
9092   {
9093     try {
9094       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9095     } catch (std::out_of_range& e) {
9096       {
9097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9098       };
9099     } catch (std::exception& e) {
9100       {
9101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9102       };
9103     } catch (Dali::DaliException e) {
9104       {
9105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9106       };
9107     } catch (...) {
9108       {
9109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9110       };
9111     }
9112   }
9113
9114   jresult = result;
9115   return jresult;
9116 }
9117
9118
9119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9120   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9121   uint16_t arg2 ;
9122
9123   arg1 = (Dali::Uint16Pair *)jarg1;
9124   arg2 = (uint16_t)jarg2;
9125   {
9126     try {
9127       (arg1)->SetHeight(arg2);
9128     } catch (std::out_of_range& e) {
9129       {
9130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9131       };
9132     } catch (std::exception& e) {
9133       {
9134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9135       };
9136     } catch (Dali::DaliException e) {
9137       {
9138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9139       };
9140     } catch (...) {
9141       {
9142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9143       };
9144     }
9145   }
9146
9147 }
9148
9149
9150 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9151   unsigned short jresult ;
9152   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9153   uint16_t result;
9154
9155   arg1 = (Dali::Uint16Pair *)jarg1;
9156   {
9157     try {
9158       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9159     } catch (std::out_of_range& e) {
9160       {
9161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9162       };
9163     } catch (std::exception& e) {
9164       {
9165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9166       };
9167     } catch (Dali::DaliException e) {
9168       {
9169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9170       };
9171     } catch (...) {
9172       {
9173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9174       };
9175     }
9176   }
9177
9178   jresult = result;
9179   return jresult;
9180 }
9181
9182
9183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9184   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9185   uint16_t arg2 ;
9186
9187   arg1 = (Dali::Uint16Pair *)jarg1;
9188   arg2 = (uint16_t)jarg2;
9189   {
9190     try {
9191       (arg1)->SetX(arg2);
9192     } catch (std::out_of_range& e) {
9193       {
9194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9195       };
9196     } catch (std::exception& e) {
9197       {
9198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9199       };
9200     } catch (Dali::DaliException e) {
9201       {
9202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9203       };
9204     } catch (...) {
9205       {
9206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9207       };
9208     }
9209   }
9210
9211 }
9212
9213
9214 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9215   unsigned short jresult ;
9216   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9217   uint16_t result;
9218
9219   arg1 = (Dali::Uint16Pair *)jarg1;
9220   {
9221     try {
9222       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9223     } catch (std::out_of_range& e) {
9224       {
9225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9226       };
9227     } catch (std::exception& e) {
9228       {
9229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9230       };
9231     } catch (Dali::DaliException e) {
9232       {
9233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9234       };
9235     } catch (...) {
9236       {
9237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9238       };
9239     }
9240   }
9241
9242   jresult = result;
9243   return jresult;
9244 }
9245
9246
9247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9248   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9249   uint16_t arg2 ;
9250
9251   arg1 = (Dali::Uint16Pair *)jarg1;
9252   arg2 = (uint16_t)jarg2;
9253   {
9254     try {
9255       (arg1)->SetY(arg2);
9256     } catch (std::out_of_range& e) {
9257       {
9258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9259       };
9260     } catch (std::exception& e) {
9261       {
9262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9263       };
9264     } catch (Dali::DaliException e) {
9265       {
9266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9267       };
9268     } catch (...) {
9269       {
9270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9271       };
9272     }
9273   }
9274
9275 }
9276
9277
9278 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9279   unsigned short jresult ;
9280   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9281   uint16_t result;
9282
9283   arg1 = (Dali::Uint16Pair *)jarg1;
9284   {
9285     try {
9286       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9287     } catch (std::out_of_range& e) {
9288       {
9289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (std::exception& e) {
9292       {
9293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9294       };
9295     } catch (Dali::DaliException e) {
9296       {
9297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9298       };
9299     } catch (...) {
9300       {
9301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9302       };
9303     }
9304   }
9305
9306   jresult = result;
9307   return jresult;
9308 }
9309
9310
9311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9312   void * jresult ;
9313   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9314   Dali::Uint16Pair *arg2 = 0 ;
9315   Dali::Uint16Pair *result = 0 ;
9316
9317   arg1 = (Dali::Uint16Pair *)jarg1;
9318   arg2 = (Dali::Uint16Pair *)jarg2;
9319   if (!arg2) {
9320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9321     return 0;
9322   }
9323   {
9324     try {
9325       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9326     } catch (std::out_of_range& e) {
9327       {
9328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (std::exception& e) {
9331       {
9332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (Dali::DaliException e) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9337       };
9338     } catch (...) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9341       };
9342     }
9343   }
9344
9345   jresult = (void *)result;
9346   return jresult;
9347 }
9348
9349
9350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9351   unsigned int jresult ;
9352   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9353   Dali::Uint16Pair *arg2 = 0 ;
9354   bool result;
9355
9356   arg1 = (Dali::Uint16Pair *)jarg1;
9357   arg2 = (Dali::Uint16Pair *)jarg2;
9358   if (!arg2) {
9359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9360     return 0;
9361   }
9362   {
9363     try {
9364       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9365     } catch (std::out_of_range& e) {
9366       {
9367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (std::exception& e) {
9370       {
9371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (Dali::DaliException e) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9376       };
9377     } catch (...) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9380       };
9381     }
9382   }
9383
9384   jresult = result;
9385   return jresult;
9386 }
9387
9388
9389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9390   unsigned int jresult ;
9391   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9392   Dali::Uint16Pair *arg2 = 0 ;
9393   bool result;
9394
9395   arg1 = (Dali::Uint16Pair *)jarg1;
9396   arg2 = (Dali::Uint16Pair *)jarg2;
9397   if (!arg2) {
9398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9399     return 0;
9400   }
9401   {
9402     try {
9403       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9404     } catch (std::out_of_range& e) {
9405       {
9406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9407       };
9408     } catch (std::exception& e) {
9409       {
9410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (Dali::DaliException e) {
9413       {
9414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9415       };
9416     } catch (...) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9419       };
9420     }
9421   }
9422
9423   jresult = result;
9424   return jresult;
9425 }
9426
9427
9428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9429   unsigned int jresult ;
9430   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9431   Dali::Uint16Pair *arg2 = 0 ;
9432   bool result;
9433
9434   arg1 = (Dali::Uint16Pair *)jarg1;
9435   arg2 = (Dali::Uint16Pair *)jarg2;
9436   if (!arg2) {
9437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9438     return 0;
9439   }
9440   {
9441     try {
9442       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9443     } catch (std::out_of_range& e) {
9444       {
9445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (std::exception& e) {
9448       {
9449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (Dali::DaliException e) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9454       };
9455     } catch (...) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9458       };
9459     }
9460   }
9461
9462   jresult = result;
9463   return jresult;
9464 }
9465
9466
9467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9468   unsigned int jresult ;
9469   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9470   Dali::Uint16Pair *arg2 = 0 ;
9471   bool result;
9472
9473   arg1 = (Dali::Uint16Pair *)jarg1;
9474   arg2 = (Dali::Uint16Pair *)jarg2;
9475   if (!arg2) {
9476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9477     return 0;
9478   }
9479   {
9480     try {
9481       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9482     } catch (std::out_of_range& e) {
9483       {
9484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9485       };
9486     } catch (std::exception& e) {
9487       {
9488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9489       };
9490     } catch (Dali::DaliException e) {
9491       {
9492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9493       };
9494     } catch (...) {
9495       {
9496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9497       };
9498     }
9499   }
9500
9501   jresult = result;
9502   return jresult;
9503 }
9504
9505
9506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9507   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9508
9509   arg1 = (Dali::Uint16Pair *)jarg1;
9510   {
9511     try {
9512       delete arg1;
9513     } catch (std::out_of_range& e) {
9514       {
9515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9516       };
9517     } catch (std::exception& e) {
9518       {
9519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9520       };
9521     } catch (Dali::DaliException e) {
9522       {
9523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9524       };
9525     } catch (...) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9528       };
9529     }
9530   }
9531
9532 }
9533
9534
9535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9536   void * jresult ;
9537   Dali::Degree *result = 0 ;
9538
9539   {
9540     try {
9541       result = (Dali::Degree *)new Dali::Degree();
9542     } catch (std::out_of_range& e) {
9543       {
9544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9545       };
9546     } catch (std::exception& e) {
9547       {
9548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9549       };
9550     } catch (Dali::DaliException e) {
9551       {
9552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9553       };
9554     } catch (...) {
9555       {
9556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9557       };
9558     }
9559   }
9560
9561   jresult = (void *)result;
9562   return jresult;
9563 }
9564
9565
9566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9567   void * jresult ;
9568   float arg1 ;
9569   Dali::Degree *result = 0 ;
9570
9571   arg1 = (float)jarg1;
9572   {
9573     try {
9574       result = (Dali::Degree *)new Dali::Degree(arg1);
9575     } catch (std::out_of_range& e) {
9576       {
9577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (std::exception& e) {
9580       {
9581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (Dali::DaliException e) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9586       };
9587     } catch (...) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9590       };
9591     }
9592   }
9593
9594   jresult = (void *)result;
9595   return jresult;
9596 }
9597
9598
9599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9600   void * jresult ;
9601   Dali::Radian arg1 ;
9602   Dali::Radian *argp1 ;
9603   Dali::Degree *result = 0 ;
9604
9605   argp1 = (Dali::Radian *)jarg1;
9606   if (!argp1) {
9607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9608     return 0;
9609   }
9610   arg1 = *argp1;
9611   {
9612     try {
9613       result = (Dali::Degree *)new Dali::Degree(arg1);
9614     } catch (std::out_of_range& e) {
9615       {
9616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9617       };
9618     } catch (std::exception& e) {
9619       {
9620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (Dali::DaliException e) {
9623       {
9624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9625       };
9626     } catch (...) {
9627       {
9628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9629       };
9630     }
9631   }
9632
9633   jresult = (void *)result;
9634   return jresult;
9635 }
9636
9637
9638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9639   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9640   float arg2 ;
9641
9642   arg1 = (Dali::Degree *)jarg1;
9643   arg2 = (float)jarg2;
9644   if (arg1) (arg1)->degree = arg2;
9645 }
9646
9647
9648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9649   float jresult ;
9650   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9651   float result;
9652
9653   arg1 = (Dali::Degree *)jarg1;
9654   result = (float) ((arg1)->degree);
9655   jresult = result;
9656   return jresult;
9657 }
9658
9659
9660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9661   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9662
9663   arg1 = (Dali::Degree *)jarg1;
9664   {
9665     try {
9666       delete arg1;
9667     } catch (std::out_of_range& e) {
9668       {
9669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9670       };
9671     } catch (std::exception& e) {
9672       {
9673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9674       };
9675     } catch (Dali::DaliException e) {
9676       {
9677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9678       };
9679     } catch (...) {
9680       {
9681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9682       };
9683     }
9684   }
9685
9686 }
9687
9688
9689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9690   void * jresult ;
9691   Dali::Radian *result = 0 ;
9692
9693   result = (Dali::Radian *)&Dali::ANGLE_360;
9694   jresult = (void *)result;
9695   return jresult;
9696 }
9697
9698
9699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9700   void * jresult ;
9701   Dali::Radian *result = 0 ;
9702
9703   result = (Dali::Radian *)&Dali::ANGLE_315;
9704   jresult = (void *)result;
9705   return jresult;
9706 }
9707
9708
9709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9710   void * jresult ;
9711   Dali::Radian *result = 0 ;
9712
9713   result = (Dali::Radian *)&Dali::ANGLE_270;
9714   jresult = (void *)result;
9715   return jresult;
9716 }
9717
9718
9719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9720   void * jresult ;
9721   Dali::Radian *result = 0 ;
9722
9723   result = (Dali::Radian *)&Dali::ANGLE_225;
9724   jresult = (void *)result;
9725   return jresult;
9726 }
9727
9728
9729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9730   void * jresult ;
9731   Dali::Radian *result = 0 ;
9732
9733   result = (Dali::Radian *)&Dali::ANGLE_180;
9734   jresult = (void *)result;
9735   return jresult;
9736 }
9737
9738
9739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9740   void * jresult ;
9741   Dali::Radian *result = 0 ;
9742
9743   result = (Dali::Radian *)&Dali::ANGLE_135;
9744   jresult = (void *)result;
9745   return jresult;
9746 }
9747
9748
9749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9750   void * jresult ;
9751   Dali::Radian *result = 0 ;
9752
9753   result = (Dali::Radian *)&Dali::ANGLE_120;
9754   jresult = (void *)result;
9755   return jresult;
9756 }
9757
9758
9759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9760   void * jresult ;
9761   Dali::Radian *result = 0 ;
9762
9763   result = (Dali::Radian *)&Dali::ANGLE_90;
9764   jresult = (void *)result;
9765   return jresult;
9766 }
9767
9768
9769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9770   void * jresult ;
9771   Dali::Radian *result = 0 ;
9772
9773   result = (Dali::Radian *)&Dali::ANGLE_60;
9774   jresult = (void *)result;
9775   return jresult;
9776 }
9777
9778
9779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9780   void * jresult ;
9781   Dali::Radian *result = 0 ;
9782
9783   result = (Dali::Radian *)&Dali::ANGLE_45;
9784   jresult = (void *)result;
9785   return jresult;
9786 }
9787
9788
9789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9790   void * jresult ;
9791   Dali::Radian *result = 0 ;
9792
9793   result = (Dali::Radian *)&Dali::ANGLE_30;
9794   jresult = (void *)result;
9795   return jresult;
9796 }
9797
9798
9799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9800   void * jresult ;
9801   Dali::Radian *result = 0 ;
9802
9803   result = (Dali::Radian *)&Dali::ANGLE_0;
9804   jresult = (void *)result;
9805   return jresult;
9806 }
9807
9808
9809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9810   unsigned int jresult ;
9811   Dali::Degree *arg1 = 0 ;
9812   Dali::Degree *arg2 = 0 ;
9813   bool result;
9814
9815   arg1 = (Dali::Degree *)jarg1;
9816   if (!arg1) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9818     return 0;
9819   }
9820   arg2 = (Dali::Degree *)jarg2;
9821   if (!arg2) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   {
9826     try {
9827       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9828     } catch (std::out_of_range& e) {
9829       {
9830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9831       };
9832     } catch (std::exception& e) {
9833       {
9834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (Dali::DaliException e) {
9837       {
9838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9839       };
9840     } catch (...) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9843       };
9844     }
9845   }
9846
9847   jresult = result;
9848   return jresult;
9849 }
9850
9851
9852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9853   unsigned int jresult ;
9854   Dali::Degree *arg1 = 0 ;
9855   Dali::Degree *arg2 = 0 ;
9856   bool result;
9857
9858   arg1 = (Dali::Degree *)jarg1;
9859   if (!arg1) {
9860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9861     return 0;
9862   }
9863   arg2 = (Dali::Degree *)jarg2;
9864   if (!arg2) {
9865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9866     return 0;
9867   }
9868   {
9869     try {
9870       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9871     } catch (std::out_of_range& e) {
9872       {
9873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9874       };
9875     } catch (std::exception& e) {
9876       {
9877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (Dali::DaliException e) {
9880       {
9881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9882       };
9883     } catch (...) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9886       };
9887     }
9888   }
9889
9890   jresult = result;
9891   return jresult;
9892 }
9893
9894
9895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9896   void * jresult ;
9897   Dali::Degree arg1 ;
9898   float arg2 ;
9899   float arg3 ;
9900   Dali::Degree *argp1 ;
9901   Dali::Degree result;
9902
9903   argp1 = (Dali::Degree *)jarg1;
9904   if (!argp1) {
9905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9906     return 0;
9907   }
9908   arg1 = *argp1;
9909   arg2 = (float)jarg2;
9910   arg3 = (float)jarg3;
9911   {
9912     try {
9913       result = Dali::Clamp(arg1,arg2,arg3);
9914     } catch (std::out_of_range& e) {
9915       {
9916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9917       };
9918     } catch (std::exception& e) {
9919       {
9920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (Dali::DaliException e) {
9923       {
9924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9925       };
9926     } catch (...) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9929       };
9930     }
9931   }
9932
9933   jresult = new Dali::Degree((const Dali::Degree &)result);
9934   return jresult;
9935 }
9936
9937
9938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9939   void * jresult ;
9940   Dali::Radian *result = 0 ;
9941
9942   {
9943     try {
9944       result = (Dali::Radian *)new Dali::Radian();
9945     } catch (std::out_of_range& e) {
9946       {
9947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9948       };
9949     } catch (std::exception& e) {
9950       {
9951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9952       };
9953     } catch (Dali::DaliException e) {
9954       {
9955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9956       };
9957     } catch (...) {
9958       {
9959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9960       };
9961     }
9962   }
9963
9964   jresult = (void *)result;
9965   return jresult;
9966 }
9967
9968
9969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9970   void * jresult ;
9971   float arg1 ;
9972   Dali::Radian *result = 0 ;
9973
9974   arg1 = (float)jarg1;
9975   {
9976     try {
9977       result = (Dali::Radian *)new Dali::Radian(arg1);
9978     } catch (std::out_of_range& e) {
9979       {
9980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (std::exception& e) {
9983       {
9984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (Dali::DaliException e) {
9987       {
9988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9989       };
9990     } catch (...) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9993       };
9994     }
9995   }
9996
9997   jresult = (void *)result;
9998   return jresult;
9999 }
10000
10001
10002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10003   void * jresult ;
10004   Dali::Degree arg1 ;
10005   Dali::Degree *argp1 ;
10006   Dali::Radian *result = 0 ;
10007
10008   argp1 = (Dali::Degree *)jarg1;
10009   if (!argp1) {
10010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10011     return 0;
10012   }
10013   arg1 = *argp1;
10014   {
10015     try {
10016       result = (Dali::Radian *)new Dali::Radian(arg1);
10017     } catch (std::out_of_range& e) {
10018       {
10019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10020       };
10021     } catch (std::exception& e) {
10022       {
10023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10024       };
10025     } catch (Dali::DaliException e) {
10026       {
10027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10028       };
10029     } catch (...) {
10030       {
10031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10032       };
10033     }
10034   }
10035
10036   jresult = (void *)result;
10037   return jresult;
10038 }
10039
10040
10041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10042   void * jresult ;
10043   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10044   float arg2 ;
10045   Dali::Radian *result = 0 ;
10046
10047   arg1 = (Dali::Radian *)jarg1;
10048   arg2 = (float)jarg2;
10049   {
10050     try {
10051       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10052     } catch (std::out_of_range& e) {
10053       {
10054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10055       };
10056     } catch (std::exception& e) {
10057       {
10058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (Dali::DaliException e) {
10061       {
10062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10063       };
10064     } catch (...) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10067       };
10068     }
10069   }
10070
10071   jresult = (void *)result;
10072   return jresult;
10073 }
10074
10075
10076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10077   void * jresult ;
10078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10079   Dali::Degree arg2 ;
10080   Dali::Degree *argp2 ;
10081   Dali::Radian *result = 0 ;
10082
10083   arg1 = (Dali::Radian *)jarg1;
10084   argp2 = (Dali::Degree *)jarg2;
10085   if (!argp2) {
10086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10087     return 0;
10088   }
10089   arg2 = *argp2;
10090   {
10091     try {
10092       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10093     } catch (std::out_of_range& e) {
10094       {
10095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10096       };
10097     } catch (std::exception& e) {
10098       {
10099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10100       };
10101     } catch (Dali::DaliException e) {
10102       {
10103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10104       };
10105     } catch (...) {
10106       {
10107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10108       };
10109     }
10110   }
10111
10112   jresult = (void *)result;
10113   return jresult;
10114 }
10115
10116
10117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10118   float jresult ;
10119   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10120   float result;
10121
10122   arg1 = (Dali::Radian *)jarg1;
10123   {
10124     try {
10125       result = (float)((Dali::Radian const *)arg1)->operator float();
10126     } catch (std::out_of_range& e) {
10127       {
10128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10129       };
10130     } catch (std::exception& e) {
10131       {
10132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (Dali::DaliException e) {
10135       {
10136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10137       };
10138     } catch (...) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10141       };
10142     }
10143   }
10144
10145   jresult = result;
10146   return jresult;
10147 }
10148
10149
10150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10151   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10152   float arg2 ;
10153
10154   arg1 = (Dali::Radian *)jarg1;
10155   arg2 = (float)jarg2;
10156   if (arg1) (arg1)->radian = arg2;
10157 }
10158
10159
10160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10161   float jresult ;
10162   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10163   float result;
10164
10165   arg1 = (Dali::Radian *)jarg1;
10166   result = (float) ((arg1)->radian);
10167   jresult = result;
10168   return jresult;
10169 }
10170
10171
10172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10173   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10174
10175   arg1 = (Dali::Radian *)jarg1;
10176   {
10177     try {
10178       delete arg1;
10179     } catch (std::out_of_range& e) {
10180       {
10181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10182       };
10183     } catch (std::exception& e) {
10184       {
10185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10186       };
10187     } catch (Dali::DaliException e) {
10188       {
10189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10190       };
10191     } catch (...) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10194       };
10195     }
10196   }
10197
10198 }
10199
10200
10201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10202   unsigned int jresult ;
10203   Dali::Radian arg1 ;
10204   Dali::Radian arg2 ;
10205   Dali::Radian *argp1 ;
10206   Dali::Radian *argp2 ;
10207   bool result;
10208
10209   argp1 = (Dali::Radian *)jarg1;
10210   if (!argp1) {
10211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10212     return 0;
10213   }
10214   arg1 = *argp1;
10215   argp2 = (Dali::Radian *)jarg2;
10216   if (!argp2) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg2 = *argp2;
10221   {
10222     try {
10223       result = (bool)Dali::operator ==(arg1,arg2);
10224     } catch (std::out_of_range& e) {
10225       {
10226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10227       };
10228     } catch (std::exception& e) {
10229       {
10230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (Dali::DaliException e) {
10233       {
10234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10235       };
10236     } catch (...) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10239       };
10240     }
10241   }
10242
10243   jresult = result;
10244   return jresult;
10245 }
10246
10247
10248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10249   unsigned int jresult ;
10250   Dali::Radian arg1 ;
10251   Dali::Radian arg2 ;
10252   Dali::Radian *argp1 ;
10253   Dali::Radian *argp2 ;
10254   bool result;
10255
10256   argp1 = (Dali::Radian *)jarg1;
10257   if (!argp1) {
10258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10259     return 0;
10260   }
10261   arg1 = *argp1;
10262   argp2 = (Dali::Radian *)jarg2;
10263   if (!argp2) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg2 = *argp2;
10268   {
10269     try {
10270       result = (bool)Dali::operator !=(arg1,arg2);
10271     } catch (std::out_of_range& e) {
10272       {
10273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10274       };
10275     } catch (std::exception& e) {
10276       {
10277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (Dali::DaliException e) {
10280       {
10281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10282       };
10283     } catch (...) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10286       };
10287     }
10288   }
10289
10290   jresult = result;
10291   return jresult;
10292 }
10293
10294
10295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10296   unsigned int jresult ;
10297   Dali::Radian arg1 ;
10298   Dali::Degree arg2 ;
10299   Dali::Radian *argp1 ;
10300   Dali::Degree *argp2 ;
10301   bool result;
10302
10303   argp1 = (Dali::Radian *)jarg1;
10304   if (!argp1) {
10305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10306     return 0;
10307   }
10308   arg1 = *argp1;
10309   argp2 = (Dali::Degree *)jarg2;
10310   if (!argp2) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10312     return 0;
10313   }
10314   arg2 = *argp2;
10315   {
10316     try {
10317       result = (bool)Dali::operator ==(arg1,arg2);
10318     } catch (std::out_of_range& e) {
10319       {
10320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10321       };
10322     } catch (std::exception& e) {
10323       {
10324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10325       };
10326     } catch (Dali::DaliException e) {
10327       {
10328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10329       };
10330     } catch (...) {
10331       {
10332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10333       };
10334     }
10335   }
10336
10337   jresult = result;
10338   return jresult;
10339 }
10340
10341
10342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10343   unsigned int jresult ;
10344   Dali::Radian arg1 ;
10345   Dali::Degree arg2 ;
10346   Dali::Radian *argp1 ;
10347   Dali::Degree *argp2 ;
10348   bool result;
10349
10350   argp1 = (Dali::Radian *)jarg1;
10351   if (!argp1) {
10352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10353     return 0;
10354   }
10355   arg1 = *argp1;
10356   argp2 = (Dali::Degree *)jarg2;
10357   if (!argp2) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10359     return 0;
10360   }
10361   arg2 = *argp2;
10362   {
10363     try {
10364       result = (bool)Dali::operator !=(arg1,arg2);
10365     } catch (std::out_of_range& e) {
10366       {
10367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10368       };
10369     } catch (std::exception& e) {
10370       {
10371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (Dali::DaliException e) {
10374       {
10375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10376       };
10377     } catch (...) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10380       };
10381     }
10382   }
10383
10384   jresult = result;
10385   return jresult;
10386 }
10387
10388
10389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10390   unsigned int jresult ;
10391   Dali::Degree arg1 ;
10392   Dali::Radian arg2 ;
10393   Dali::Degree *argp1 ;
10394   Dali::Radian *argp2 ;
10395   bool result;
10396
10397   argp1 = (Dali::Degree *)jarg1;
10398   if (!argp1) {
10399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10400     return 0;
10401   }
10402   arg1 = *argp1;
10403   argp2 = (Dali::Radian *)jarg2;
10404   if (!argp2) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10406     return 0;
10407   }
10408   arg2 = *argp2;
10409   {
10410     try {
10411       result = (bool)Dali::operator ==(arg1,arg2);
10412     } catch (std::out_of_range& e) {
10413       {
10414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10415       };
10416     } catch (std::exception& e) {
10417       {
10418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (Dali::DaliException e) {
10421       {
10422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10423       };
10424     } catch (...) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10427       };
10428     }
10429   }
10430
10431   jresult = result;
10432   return jresult;
10433 }
10434
10435
10436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10437   unsigned int jresult ;
10438   Dali::Degree arg1 ;
10439   Dali::Radian arg2 ;
10440   Dali::Degree *argp1 ;
10441   Dali::Radian *argp2 ;
10442   bool result;
10443
10444   argp1 = (Dali::Degree *)jarg1;
10445   if (!argp1) {
10446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10447     return 0;
10448   }
10449   arg1 = *argp1;
10450   argp2 = (Dali::Radian *)jarg2;
10451   if (!argp2) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10453     return 0;
10454   }
10455   arg2 = *argp2;
10456   {
10457     try {
10458       result = (bool)Dali::operator !=(arg1,arg2);
10459     } catch (std::out_of_range& e) {
10460       {
10461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10462       };
10463     } catch (std::exception& e) {
10464       {
10465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (Dali::DaliException e) {
10468       {
10469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10470       };
10471     } catch (...) {
10472       {
10473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10474       };
10475     }
10476   }
10477
10478   jresult = result;
10479   return jresult;
10480 }
10481
10482
10483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10484   unsigned int jresult ;
10485   Dali::Radian arg1 ;
10486   Dali::Radian arg2 ;
10487   Dali::Radian *argp1 ;
10488   Dali::Radian *argp2 ;
10489   bool result;
10490
10491   argp1 = (Dali::Radian *)jarg1;
10492   if (!argp1) {
10493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10494     return 0;
10495   }
10496   arg1 = *argp1;
10497   argp2 = (Dali::Radian *)jarg2;
10498   if (!argp2) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg2 = *argp2;
10503   {
10504     try {
10505       result = (bool)Dali::operator >(arg1,arg2);
10506     } catch (std::out_of_range& e) {
10507       {
10508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10509       };
10510     } catch (std::exception& e) {
10511       {
10512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (Dali::DaliException e) {
10515       {
10516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10517       };
10518     } catch (...) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10521       };
10522     }
10523   }
10524
10525   jresult = result;
10526   return jresult;
10527 }
10528
10529
10530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10531   unsigned int jresult ;
10532   Dali::Radian arg1 ;
10533   Dali::Degree arg2 ;
10534   Dali::Radian *argp1 ;
10535   Dali::Degree *argp2 ;
10536   bool result;
10537
10538   argp1 = (Dali::Radian *)jarg1;
10539   if (!argp1) {
10540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10541     return 0;
10542   }
10543   arg1 = *argp1;
10544   argp2 = (Dali::Degree *)jarg2;
10545   if (!argp2) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10547     return 0;
10548   }
10549   arg2 = *argp2;
10550   {
10551     try {
10552       result = (bool)Dali::operator >(arg1,arg2);
10553     } catch (std::out_of_range& e) {
10554       {
10555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10556       };
10557     } catch (std::exception& e) {
10558       {
10559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10560       };
10561     } catch (Dali::DaliException e) {
10562       {
10563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10564       };
10565     } catch (...) {
10566       {
10567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10568       };
10569     }
10570   }
10571
10572   jresult = result;
10573   return jresult;
10574 }
10575
10576
10577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10578   unsigned int jresult ;
10579   Dali::Degree arg1 ;
10580   Dali::Radian arg2 ;
10581   Dali::Degree *argp1 ;
10582   Dali::Radian *argp2 ;
10583   bool result;
10584
10585   argp1 = (Dali::Degree *)jarg1;
10586   if (!argp1) {
10587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10588     return 0;
10589   }
10590   arg1 = *argp1;
10591   argp2 = (Dali::Radian *)jarg2;
10592   if (!argp2) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10594     return 0;
10595   }
10596   arg2 = *argp2;
10597   {
10598     try {
10599       result = (bool)Dali::operator >(arg1,arg2);
10600     } catch (std::out_of_range& e) {
10601       {
10602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10603       };
10604     } catch (std::exception& e) {
10605       {
10606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10607       };
10608     } catch (Dali::DaliException e) {
10609       {
10610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10611       };
10612     } catch (...) {
10613       {
10614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10615       };
10616     }
10617   }
10618
10619   jresult = result;
10620   return jresult;
10621 }
10622
10623
10624 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10625   unsigned int jresult ;
10626   Dali::Radian arg1 ;
10627   Dali::Radian arg2 ;
10628   Dali::Radian *argp1 ;
10629   Dali::Radian *argp2 ;
10630   bool result;
10631
10632   argp1 = (Dali::Radian *)jarg1;
10633   if (!argp1) {
10634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10635     return 0;
10636   }
10637   arg1 = *argp1;
10638   argp2 = (Dali::Radian *)jarg2;
10639   if (!argp2) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg2 = *argp2;
10644   {
10645     try {
10646       result = (bool)Dali::operator <(arg1,arg2);
10647     } catch (std::out_of_range& e) {
10648       {
10649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10650       };
10651     } catch (std::exception& e) {
10652       {
10653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10654       };
10655     } catch (Dali::DaliException e) {
10656       {
10657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10658       };
10659     } catch (...) {
10660       {
10661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10662       };
10663     }
10664   }
10665
10666   jresult = result;
10667   return jresult;
10668 }
10669
10670
10671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10672   unsigned int jresult ;
10673   Dali::Radian arg1 ;
10674   Dali::Degree arg2 ;
10675   Dali::Radian *argp1 ;
10676   Dali::Degree *argp2 ;
10677   bool result;
10678
10679   argp1 = (Dali::Radian *)jarg1;
10680   if (!argp1) {
10681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10682     return 0;
10683   }
10684   arg1 = *argp1;
10685   argp2 = (Dali::Degree *)jarg2;
10686   if (!argp2) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10688     return 0;
10689   }
10690   arg2 = *argp2;
10691   {
10692     try {
10693       result = (bool)Dali::operator <(arg1,arg2);
10694     } catch (std::out_of_range& e) {
10695       {
10696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10697       };
10698     } catch (std::exception& e) {
10699       {
10700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10701       };
10702     } catch (Dali::DaliException e) {
10703       {
10704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10705       };
10706     } catch (...) {
10707       {
10708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10709       };
10710     }
10711   }
10712
10713   jresult = result;
10714   return jresult;
10715 }
10716
10717
10718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10719   unsigned int jresult ;
10720   Dali::Degree arg1 ;
10721   Dali::Radian arg2 ;
10722   Dali::Degree *argp1 ;
10723   Dali::Radian *argp2 ;
10724   bool result;
10725
10726   argp1 = (Dali::Degree *)jarg1;
10727   if (!argp1) {
10728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10729     return 0;
10730   }
10731   arg1 = *argp1;
10732   argp2 = (Dali::Radian *)jarg2;
10733   if (!argp2) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10735     return 0;
10736   }
10737   arg2 = *argp2;
10738   {
10739     try {
10740       result = (bool)Dali::operator <(arg1,arg2);
10741     } catch (std::out_of_range& e) {
10742       {
10743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10744       };
10745     } catch (std::exception& e) {
10746       {
10747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (Dali::DaliException e) {
10750       {
10751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10752       };
10753     } catch (...) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10756       };
10757     }
10758   }
10759
10760   jresult = result;
10761   return jresult;
10762 }
10763
10764
10765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10766   void * jresult ;
10767   Dali::Radian arg1 ;
10768   float arg2 ;
10769   Dali::Radian *argp1 ;
10770   Dali::Radian result;
10771
10772   argp1 = (Dali::Radian *)jarg1;
10773   if (!argp1) {
10774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10775     return 0;
10776   }
10777   arg1 = *argp1;
10778   arg2 = (float)jarg2;
10779   {
10780     try {
10781       result = Dali::operator *(arg1,arg2);
10782     } catch (std::out_of_range& e) {
10783       {
10784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10785       };
10786     } catch (std::exception& e) {
10787       {
10788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (Dali::DaliException e) {
10791       {
10792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10793       };
10794     } catch (...) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10797       };
10798     }
10799   }
10800
10801   jresult = new Dali::Radian((const Dali::Radian &)result);
10802   return jresult;
10803 }
10804
10805
10806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10807   void * jresult ;
10808   Dali::Radian arg1 ;
10809   Dali::Radian *argp1 ;
10810   Dali::Radian result;
10811
10812   argp1 = (Dali::Radian *)jarg1;
10813   if (!argp1) {
10814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10815     return 0;
10816   }
10817   arg1 = *argp1;
10818   {
10819     try {
10820       result = Dali::operator -(arg1);
10821     } catch (std::out_of_range& e) {
10822       {
10823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10824       };
10825     } catch (std::exception& e) {
10826       {
10827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (Dali::DaliException e) {
10830       {
10831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839
10840   jresult = new Dali::Radian((const Dali::Radian &)result);
10841   return jresult;
10842 }
10843
10844
10845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10846   void * jresult ;
10847   Dali::Radian arg1 ;
10848   float arg2 ;
10849   float arg3 ;
10850   Dali::Radian *argp1 ;
10851   Dali::Radian result;
10852
10853   argp1 = (Dali::Radian *)jarg1;
10854   if (!argp1) {
10855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10856     return 0;
10857   }
10858   arg1 = *argp1;
10859   arg2 = (float)jarg2;
10860   arg3 = (float)jarg3;
10861   {
10862     try {
10863       result = Dali::Clamp(arg1,arg2,arg3);
10864     } catch (std::out_of_range& e) {
10865       {
10866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10867       };
10868     } catch (std::exception& e) {
10869       {
10870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (Dali::DaliException e) {
10873       {
10874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10875       };
10876     } catch (...) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10879       };
10880     }
10881   }
10882
10883   jresult = new Dali::Radian((const Dali::Radian &)result);
10884   return jresult;
10885 }
10886
10887
10888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10889   void * jresult ;
10890   Dali::Quaternion *result = 0 ;
10891
10892   {
10893     try {
10894       result = (Dali::Quaternion *)new Dali::Quaternion();
10895     } catch (std::out_of_range& e) {
10896       {
10897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10898       };
10899     } catch (std::exception& e) {
10900       {
10901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (Dali::DaliException e) {
10904       {
10905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10906       };
10907     } catch (...) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10910       };
10911     }
10912   }
10913
10914   jresult = (void *)result;
10915   return jresult;
10916 }
10917
10918
10919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10920   void * jresult ;
10921   Dali::Radian arg1 ;
10922   Dali::Vector3 *arg2 = 0 ;
10923   Dali::Radian *argp1 ;
10924   Dali::Quaternion *result = 0 ;
10925
10926   argp1 = (Dali::Radian *)jarg1;
10927   if (!argp1) {
10928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10929     return 0;
10930   }
10931   arg1 = *argp1;
10932   arg2 = (Dali::Vector3 *)jarg2;
10933   if (!arg2) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10935     return 0;
10936   }
10937   {
10938     try {
10939       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10940     } catch (std::out_of_range& e) {
10941       {
10942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10943       };
10944     } catch (std::exception& e) {
10945       {
10946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (Dali::DaliException e) {
10949       {
10950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10951       };
10952     } catch (...) {
10953       {
10954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10955       };
10956     }
10957   }
10958
10959   jresult = (void *)result;
10960   return jresult;
10961 }
10962
10963
10964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10965   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10966
10967   arg1 = (Dali::Quaternion *)jarg1;
10968   {
10969     try {
10970       delete arg1;
10971     } catch (std::out_of_range& e) {
10972       {
10973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10974       };
10975     } catch (std::exception& e) {
10976       {
10977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10978       };
10979     } catch (Dali::DaliException e) {
10980       {
10981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10982       };
10983     } catch (...) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10986       };
10987     }
10988   }
10989
10990 }
10991
10992
10993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10994   void * jresult ;
10995   Dali::Quaternion *result = 0 ;
10996
10997   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10998   jresult = (void *)result;
10999   return jresult;
11000 }
11001
11002
11003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11004   unsigned int jresult ;
11005   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11006   bool result;
11007
11008   arg1 = (Dali::Quaternion *)jarg1;
11009   {
11010     try {
11011       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11012     } catch (std::out_of_range& e) {
11013       {
11014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11015       };
11016     } catch (std::exception& e) {
11017       {
11018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11019       };
11020     } catch (Dali::DaliException e) {
11021       {
11022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11023       };
11024     } catch (...) {
11025       {
11026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11027       };
11028     }
11029   }
11030
11031   jresult = result;
11032   return jresult;
11033 }
11034
11035
11036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11037   unsigned int jresult ;
11038   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11039   Dali::Vector3 *arg2 = 0 ;
11040   Dali::Radian *arg3 = 0 ;
11041   bool result;
11042
11043   arg1 = (Dali::Quaternion *)jarg1;
11044   arg2 = (Dali::Vector3 *)jarg2;
11045   if (!arg2) {
11046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11047     return 0;
11048   }
11049   arg3 = (Dali::Radian *)jarg3;
11050   if (!arg3) {
11051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11052     return 0;
11053   }
11054   {
11055     try {
11056       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11057     } catch (std::out_of_range& e) {
11058       {
11059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11060       };
11061     } catch (std::exception& e) {
11062       {
11063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11064       };
11065     } catch (Dali::DaliException e) {
11066       {
11067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11068       };
11069     } catch (...) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11072       };
11073     }
11074   }
11075
11076   jresult = result;
11077   return jresult;
11078 }
11079
11080
11081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11082   void * jresult ;
11083   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11084   Dali::Quaternion *arg2 = 0 ;
11085   Dali::Quaternion result;
11086
11087   arg1 = (Dali::Quaternion *)jarg1;
11088   arg2 = (Dali::Quaternion *)jarg2;
11089   if (!arg2) {
11090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11091     return 0;
11092   }
11093   {
11094     try {
11095       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11096     } catch (std::out_of_range& e) {
11097       {
11098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11099       };
11100     } catch (std::exception& e) {
11101       {
11102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11103       };
11104     } catch (Dali::DaliException e) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11107       };
11108     } catch (...) {
11109       {
11110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11111       };
11112     }
11113   }
11114
11115   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11116   return jresult;
11117 }
11118
11119
11120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11121   void * jresult ;
11122   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11123   Dali::Quaternion *arg2 = 0 ;
11124   Dali::Quaternion result;
11125
11126   arg1 = (Dali::Quaternion *)jarg1;
11127   arg2 = (Dali::Quaternion *)jarg2;
11128   if (!arg2) {
11129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11130     return 0;
11131   }
11132   {
11133     try {
11134       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11135     } catch (std::out_of_range& e) {
11136       {
11137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11138       };
11139     } catch (std::exception& e) {
11140       {
11141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (Dali::DaliException e) {
11144       {
11145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11146       };
11147     } catch (...) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11150       };
11151     }
11152   }
11153
11154   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11155   return jresult;
11156 }
11157
11158
11159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11160   void * jresult ;
11161   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11162   Dali::Quaternion *arg2 = 0 ;
11163   Dali::Quaternion result;
11164
11165   arg1 = (Dali::Quaternion *)jarg1;
11166   arg2 = (Dali::Quaternion *)jarg2;
11167   if (!arg2) {
11168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11169     return 0;
11170   }
11171   {
11172     try {
11173       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11174     } catch (std::out_of_range& e) {
11175       {
11176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (std::exception& e) {
11179       {
11180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (Dali::DaliException e) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11185       };
11186     } catch (...) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11189       };
11190     }
11191   }
11192
11193   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11194   return jresult;
11195 }
11196
11197
11198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11199   void * jresult ;
11200   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11201   Dali::Vector3 *arg2 = 0 ;
11202   Dali::Vector3 result;
11203
11204   arg1 = (Dali::Quaternion *)jarg1;
11205   arg2 = (Dali::Vector3 *)jarg2;
11206   if (!arg2) {
11207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11208     return 0;
11209   }
11210   {
11211     try {
11212       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11213     } catch (std::out_of_range& e) {
11214       {
11215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11216       };
11217     } catch (std::exception& e) {
11218       {
11219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11220       };
11221     } catch (Dali::DaliException e) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11224       };
11225     } catch (...) {
11226       {
11227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11228       };
11229     }
11230   }
11231
11232   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11233   return jresult;
11234 }
11235
11236
11237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11238   void * jresult ;
11239   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11240   Dali::Quaternion *arg2 = 0 ;
11241   Dali::Quaternion result;
11242
11243   arg1 = (Dali::Quaternion *)jarg1;
11244   arg2 = (Dali::Quaternion *)jarg2;
11245   if (!arg2) {
11246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11247     return 0;
11248   }
11249   {
11250     try {
11251       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11252     } catch (std::out_of_range& e) {
11253       {
11254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11255       };
11256     } catch (std::exception& e) {
11257       {
11258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11259       };
11260     } catch (Dali::DaliException e) {
11261       {
11262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11263       };
11264     } catch (...) {
11265       {
11266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11267       };
11268     }
11269   }
11270
11271   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11272   return jresult;
11273 }
11274
11275
11276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11277   void * jresult ;
11278   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11279   float arg2 ;
11280   Dali::Quaternion result;
11281
11282   arg1 = (Dali::Quaternion *)jarg1;
11283   arg2 = (float)jarg2;
11284   {
11285     try {
11286       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11287     } catch (std::out_of_range& e) {
11288       {
11289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11290       };
11291     } catch (std::exception& e) {
11292       {
11293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11294       };
11295     } catch (Dali::DaliException e) {
11296       {
11297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11298       };
11299     } catch (...) {
11300       {
11301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11302       };
11303     }
11304   }
11305
11306   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11307   return jresult;
11308 }
11309
11310
11311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11312   void * jresult ;
11313   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11314   float arg2 ;
11315   Dali::Quaternion result;
11316
11317   arg1 = (Dali::Quaternion *)jarg1;
11318   arg2 = (float)jarg2;
11319   {
11320     try {
11321       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11322     } catch (std::out_of_range& e) {
11323       {
11324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11325       };
11326     } catch (std::exception& e) {
11327       {
11328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11329       };
11330     } catch (Dali::DaliException e) {
11331       {
11332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11333       };
11334     } catch (...) {
11335       {
11336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11337       };
11338     }
11339   }
11340
11341   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11342   return jresult;
11343 }
11344
11345
11346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11347   void * jresult ;
11348   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11349   Dali::Quaternion result;
11350
11351   arg1 = (Dali::Quaternion *)jarg1;
11352   {
11353     try {
11354       result = ((Dali::Quaternion const *)arg1)->operator -();
11355     } catch (std::out_of_range& e) {
11356       {
11357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11358       };
11359     } catch (std::exception& e) {
11360       {
11361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11362       };
11363     } catch (Dali::DaliException e) {
11364       {
11365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11366       };
11367     } catch (...) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11370       };
11371     }
11372   }
11373
11374   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11375   return jresult;
11376 }
11377
11378
11379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11380   void * jresult ;
11381   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11382   Dali::Quaternion *arg2 = 0 ;
11383   Dali::Quaternion *result = 0 ;
11384
11385   arg1 = (Dali::Quaternion *)jarg1;
11386   arg2 = (Dali::Quaternion *)jarg2;
11387   if (!arg2) {
11388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11389     return 0;
11390   }
11391   {
11392     try {
11393       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11394     } catch (std::out_of_range& e) {
11395       {
11396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11397       };
11398     } catch (std::exception& e) {
11399       {
11400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11401       };
11402     } catch (Dali::DaliException e) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11405       };
11406     } catch (...) {
11407       {
11408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11409       };
11410     }
11411   }
11412
11413   jresult = (void *)result;
11414   return jresult;
11415 }
11416
11417
11418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11419   void * jresult ;
11420   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11421   Dali::Quaternion *arg2 = 0 ;
11422   Dali::Quaternion *result = 0 ;
11423
11424   arg1 = (Dali::Quaternion *)jarg1;
11425   arg2 = (Dali::Quaternion *)jarg2;
11426   if (!arg2) {
11427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11428     return 0;
11429   }
11430   {
11431     try {
11432       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11433     } catch (std::out_of_range& e) {
11434       {
11435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (std::exception& e) {
11438       {
11439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (Dali::DaliException e) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11444       };
11445     } catch (...) {
11446       {
11447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11448       };
11449     }
11450   }
11451
11452   jresult = (void *)result;
11453   return jresult;
11454 }
11455
11456
11457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11458   void * jresult ;
11459   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11460   Dali::Quaternion *arg2 = 0 ;
11461   Dali::Quaternion *result = 0 ;
11462
11463   arg1 = (Dali::Quaternion *)jarg1;
11464   arg2 = (Dali::Quaternion *)jarg2;
11465   if (!arg2) {
11466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11467     return 0;
11468   }
11469   {
11470     try {
11471       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11472     } catch (std::out_of_range& e) {
11473       {
11474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11475       };
11476     } catch (std::exception& e) {
11477       {
11478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11479       };
11480     } catch (Dali::DaliException e) {
11481       {
11482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11483       };
11484     } catch (...) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11487       };
11488     }
11489   }
11490
11491   jresult = (void *)result;
11492   return jresult;
11493 }
11494
11495
11496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11497   void * jresult ;
11498   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11499   float arg2 ;
11500   Dali::Quaternion *result = 0 ;
11501
11502   arg1 = (Dali::Quaternion *)jarg1;
11503   arg2 = (float)jarg2;
11504   {
11505     try {
11506       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11507     } catch (std::out_of_range& e) {
11508       {
11509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11510       };
11511     } catch (std::exception& e) {
11512       {
11513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11514       };
11515     } catch (Dali::DaliException e) {
11516       {
11517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11518       };
11519     } catch (...) {
11520       {
11521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11522       };
11523     }
11524   }
11525
11526   jresult = (void *)result;
11527   return jresult;
11528 }
11529
11530
11531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11532   void * jresult ;
11533   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11534   float arg2 ;
11535   Dali::Quaternion *result = 0 ;
11536
11537   arg1 = (Dali::Quaternion *)jarg1;
11538   arg2 = (float)jarg2;
11539   {
11540     try {
11541       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11542     } catch (std::out_of_range& e) {
11543       {
11544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11545       };
11546     } catch (std::exception& e) {
11547       {
11548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11549       };
11550     } catch (Dali::DaliException e) {
11551       {
11552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11553       };
11554     } catch (...) {
11555       {
11556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11557       };
11558     }
11559   }
11560
11561   jresult = (void *)result;
11562   return jresult;
11563 }
11564
11565
11566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11567   unsigned int jresult ;
11568   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11569   Dali::Quaternion *arg2 = 0 ;
11570   bool result;
11571
11572   arg1 = (Dali::Quaternion *)jarg1;
11573   arg2 = (Dali::Quaternion *)jarg2;
11574   if (!arg2) {
11575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11576     return 0;
11577   }
11578   {
11579     try {
11580       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11581     } catch (std::out_of_range& e) {
11582       {
11583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11584       };
11585     } catch (std::exception& e) {
11586       {
11587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11588       };
11589     } catch (Dali::DaliException e) {
11590       {
11591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11592       };
11593     } catch (...) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11596       };
11597     }
11598   }
11599
11600   jresult = result;
11601   return jresult;
11602 }
11603
11604
11605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11606   unsigned int jresult ;
11607   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11608   Dali::Quaternion *arg2 = 0 ;
11609   bool result;
11610
11611   arg1 = (Dali::Quaternion *)jarg1;
11612   arg2 = (Dali::Quaternion *)jarg2;
11613   if (!arg2) {
11614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11615     return 0;
11616   }
11617   {
11618     try {
11619       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11620     } catch (std::out_of_range& e) {
11621       {
11622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11623       };
11624     } catch (std::exception& e) {
11625       {
11626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11627       };
11628     } catch (Dali::DaliException e) {
11629       {
11630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11631       };
11632     } catch (...) {
11633       {
11634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11635       };
11636     }
11637   }
11638
11639   jresult = result;
11640   return jresult;
11641 }
11642
11643
11644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11645   float jresult ;
11646   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11647   float result;
11648
11649   arg1 = (Dali::Quaternion *)jarg1;
11650   {
11651     try {
11652       result = (float)((Dali::Quaternion const *)arg1)->Length();
11653     } catch (std::out_of_range& e) {
11654       {
11655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11656       };
11657     } catch (std::exception& e) {
11658       {
11659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11660       };
11661     } catch (Dali::DaliException e) {
11662       {
11663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11664       };
11665     } catch (...) {
11666       {
11667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11668       };
11669     }
11670   }
11671
11672   jresult = result;
11673   return jresult;
11674 }
11675
11676
11677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11678   float jresult ;
11679   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11680   float result;
11681
11682   arg1 = (Dali::Quaternion *)jarg1;
11683   {
11684     try {
11685       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11686     } catch (std::out_of_range& e) {
11687       {
11688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11689       };
11690     } catch (std::exception& e) {
11691       {
11692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11693       };
11694     } catch (Dali::DaliException e) {
11695       {
11696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11697       };
11698     } catch (...) {
11699       {
11700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11701       };
11702     }
11703   }
11704
11705   jresult = result;
11706   return jresult;
11707 }
11708
11709
11710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11711   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11712
11713   arg1 = (Dali::Quaternion *)jarg1;
11714   {
11715     try {
11716       (arg1)->Normalize();
11717     } catch (std::out_of_range& e) {
11718       {
11719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11720       };
11721     } catch (std::exception& e) {
11722       {
11723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11724       };
11725     } catch (Dali::DaliException e) {
11726       {
11727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11728       };
11729     } catch (...) {
11730       {
11731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11732       };
11733     }
11734   }
11735
11736 }
11737
11738
11739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11740   void * jresult ;
11741   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11742   Dali::Quaternion result;
11743
11744   arg1 = (Dali::Quaternion *)jarg1;
11745   {
11746     try {
11747       result = ((Dali::Quaternion const *)arg1)->Normalized();
11748     } catch (std::out_of_range& e) {
11749       {
11750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11751       };
11752     } catch (std::exception& e) {
11753       {
11754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11755       };
11756     } catch (Dali::DaliException e) {
11757       {
11758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11759       };
11760     } catch (...) {
11761       {
11762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11763       };
11764     }
11765   }
11766
11767   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11768   return jresult;
11769 }
11770
11771
11772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11773   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11774
11775   arg1 = (Dali::Quaternion *)jarg1;
11776   {
11777     try {
11778       (arg1)->Conjugate();
11779     } catch (std::out_of_range& e) {
11780       {
11781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11782       };
11783     } catch (std::exception& e) {
11784       {
11785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (Dali::DaliException e) {
11788       {
11789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11790       };
11791     } catch (...) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11794       };
11795     }
11796   }
11797
11798 }
11799
11800
11801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11802   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11803
11804   arg1 = (Dali::Quaternion *)jarg1;
11805   {
11806     try {
11807       (arg1)->Invert();
11808     } catch (std::out_of_range& e) {
11809       {
11810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11811       };
11812     } catch (std::exception& e) {
11813       {
11814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11815       };
11816     } catch (Dali::DaliException e) {
11817       {
11818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11819       };
11820     } catch (...) {
11821       {
11822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11823       };
11824     }
11825   }
11826
11827 }
11828
11829
11830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11831   void * jresult ;
11832   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11833   Dali::Quaternion result;
11834
11835   arg1 = (Dali::Quaternion *)jarg1;
11836   {
11837     try {
11838       result = ((Dali::Quaternion const *)arg1)->Log();
11839     } catch (std::out_of_range& e) {
11840       {
11841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11842       };
11843     } catch (std::exception& e) {
11844       {
11845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11846       };
11847     } catch (Dali::DaliException e) {
11848       {
11849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11850       };
11851     } catch (...) {
11852       {
11853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11854       };
11855     }
11856   }
11857
11858   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11859   return jresult;
11860 }
11861
11862
11863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11864   void * jresult ;
11865   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11866   Dali::Quaternion result;
11867
11868   arg1 = (Dali::Quaternion *)jarg1;
11869   {
11870     try {
11871       result = ((Dali::Quaternion const *)arg1)->Exp();
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (Dali::DaliException e) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11883       };
11884     } catch (...) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11887       };
11888     }
11889   }
11890
11891   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11892   return jresult;
11893 }
11894
11895
11896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11897   float jresult ;
11898   Dali::Quaternion *arg1 = 0 ;
11899   Dali::Quaternion *arg2 = 0 ;
11900   float result;
11901
11902   arg1 = (Dali::Quaternion *)jarg1;
11903   if (!arg1) {
11904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11905     return 0;
11906   }
11907   arg2 = (Dali::Quaternion *)jarg2;
11908   if (!arg2) {
11909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11910     return 0;
11911   }
11912   {
11913     try {
11914       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11915     } catch (std::out_of_range& e) {
11916       {
11917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11918       };
11919     } catch (std::exception& e) {
11920       {
11921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (Dali::DaliException e) {
11924       {
11925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11926       };
11927     } catch (...) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11930       };
11931     }
11932   }
11933
11934   jresult = result;
11935   return jresult;
11936 }
11937
11938
11939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11940   void * jresult ;
11941   Dali::Quaternion *arg1 = 0 ;
11942   Dali::Quaternion *arg2 = 0 ;
11943   float arg3 ;
11944   Dali::Quaternion result;
11945
11946   arg1 = (Dali::Quaternion *)jarg1;
11947   if (!arg1) {
11948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11949     return 0;
11950   }
11951   arg2 = (Dali::Quaternion *)jarg2;
11952   if (!arg2) {
11953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11954     return 0;
11955   }
11956   arg3 = (float)jarg3;
11957   {
11958     try {
11959       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11960     } catch (std::out_of_range& e) {
11961       {
11962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11963       };
11964     } catch (std::exception& e) {
11965       {
11966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11967       };
11968     } catch (Dali::DaliException e) {
11969       {
11970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11971       };
11972     } catch (...) {
11973       {
11974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11975       };
11976     }
11977   }
11978
11979   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11980   return jresult;
11981 }
11982
11983
11984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11985   void * jresult ;
11986   Dali::Quaternion *arg1 = 0 ;
11987   Dali::Quaternion *arg2 = 0 ;
11988   float arg3 ;
11989   Dali::Quaternion result;
11990
11991   arg1 = (Dali::Quaternion *)jarg1;
11992   if (!arg1) {
11993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11994     return 0;
11995   }
11996   arg2 = (Dali::Quaternion *)jarg2;
11997   if (!arg2) {
11998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11999     return 0;
12000   }
12001   arg3 = (float)jarg3;
12002   {
12003     try {
12004       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12005     } catch (std::out_of_range& e) {
12006       {
12007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12008       };
12009     } catch (std::exception& e) {
12010       {
12011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12012       };
12013     } catch (Dali::DaliException e) {
12014       {
12015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12016       };
12017     } catch (...) {
12018       {
12019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12020       };
12021     }
12022   }
12023
12024   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12025   return jresult;
12026 }
12027
12028
12029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12030   void * jresult ;
12031   Dali::Quaternion *arg1 = 0 ;
12032   Dali::Quaternion *arg2 = 0 ;
12033   float arg3 ;
12034   Dali::Quaternion result;
12035
12036   arg1 = (Dali::Quaternion *)jarg1;
12037   if (!arg1) {
12038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12039     return 0;
12040   }
12041   arg2 = (Dali::Quaternion *)jarg2;
12042   if (!arg2) {
12043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12044     return 0;
12045   }
12046   arg3 = (float)jarg3;
12047   {
12048     try {
12049       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12050     } catch (std::out_of_range& e) {
12051       {
12052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12053       };
12054     } catch (std::exception& e) {
12055       {
12056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12057       };
12058     } catch (Dali::DaliException e) {
12059       {
12060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12061       };
12062     } catch (...) {
12063       {
12064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12065       };
12066     }
12067   }
12068
12069   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12070   return jresult;
12071 }
12072
12073
12074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12075   void * jresult ;
12076   Dali::Quaternion *arg1 = 0 ;
12077   Dali::Quaternion *arg2 = 0 ;
12078   Dali::Quaternion *arg3 = 0 ;
12079   Dali::Quaternion *arg4 = 0 ;
12080   float arg5 ;
12081   Dali::Quaternion result;
12082
12083   arg1 = (Dali::Quaternion *)jarg1;
12084   if (!arg1) {
12085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12086     return 0;
12087   }
12088   arg2 = (Dali::Quaternion *)jarg2;
12089   if (!arg2) {
12090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12091     return 0;
12092   }
12093   arg3 = (Dali::Quaternion *)jarg3;
12094   if (!arg3) {
12095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12096     return 0;
12097   }
12098   arg4 = (Dali::Quaternion *)jarg4;
12099   if (!arg4) {
12100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12101     return 0;
12102   }
12103   arg5 = (float)jarg5;
12104   {
12105     try {
12106       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12107     } catch (std::out_of_range& e) {
12108       {
12109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12110       };
12111     } catch (std::exception& e) {
12112       {
12113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (Dali::DaliException e) {
12116       {
12117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12118       };
12119     } catch (...) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12122       };
12123     }
12124   }
12125
12126   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12127   return jresult;
12128 }
12129
12130
12131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12132   float jresult ;
12133   Dali::Quaternion *arg1 = 0 ;
12134   Dali::Quaternion *arg2 = 0 ;
12135   float result;
12136
12137   arg1 = (Dali::Quaternion *)jarg1;
12138   if (!arg1) {
12139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12140     return 0;
12141   }
12142   arg2 = (Dali::Quaternion *)jarg2;
12143   if (!arg2) {
12144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12145     return 0;
12146   }
12147   {
12148     try {
12149       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12150     } catch (std::out_of_range& e) {
12151       {
12152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12153       };
12154     } catch (std::exception& e) {
12155       {
12156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12157       };
12158     } catch (Dali::DaliException e) {
12159       {
12160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12161       };
12162     } catch (...) {
12163       {
12164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12165       };
12166     }
12167   }
12168
12169   jresult = result;
12170   return jresult;
12171 }
12172
12173
12174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12175   void * jresult ;
12176   Dali::Matrix *result = 0 ;
12177
12178   {
12179     try {
12180       result = (Dali::Matrix *)new Dali::Matrix();
12181     } catch (std::out_of_range& e) {
12182       {
12183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12184       };
12185     } catch (std::exception& e) {
12186       {
12187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12188       };
12189     } catch (Dali::DaliException e) {
12190       {
12191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12192       };
12193     } catch (...) {
12194       {
12195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12196       };
12197     }
12198   }
12199
12200   jresult = (void *)result;
12201   return jresult;
12202 }
12203
12204
12205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12206   void * jresult ;
12207   bool arg1 ;
12208   Dali::Matrix *result = 0 ;
12209
12210   arg1 = jarg1 ? true : false;
12211   {
12212     try {
12213       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12214     } catch (std::out_of_range& e) {
12215       {
12216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12217       };
12218     } catch (std::exception& e) {
12219       {
12220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (Dali::DaliException e) {
12223       {
12224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12225       };
12226     } catch (...) {
12227       {
12228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12229       };
12230     }
12231   }
12232
12233   jresult = (void *)result;
12234   return jresult;
12235 }
12236
12237
12238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12239   void * jresult ;
12240   float *arg1 = (float *) 0 ;
12241   Dali::Matrix *result = 0 ;
12242
12243   arg1 = jarg1;
12244   {
12245     try {
12246       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12247     } catch (std::out_of_range& e) {
12248       {
12249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (std::exception& e) {
12252       {
12253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (Dali::DaliException e) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12258       };
12259     } catch (...) {
12260       {
12261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12262       };
12263     }
12264   }
12265
12266   jresult = (void *)result;
12267
12268
12269   return jresult;
12270 }
12271
12272
12273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12274   void * jresult ;
12275   Dali::Quaternion *arg1 = 0 ;
12276   Dali::Matrix *result = 0 ;
12277
12278   arg1 = (Dali::Quaternion *)jarg1;
12279   if (!arg1) {
12280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12281     return 0;
12282   }
12283   {
12284     try {
12285       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12286     } catch (std::out_of_range& e) {
12287       {
12288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12289       };
12290     } catch (std::exception& e) {
12291       {
12292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12293       };
12294     } catch (Dali::DaliException e) {
12295       {
12296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12297       };
12298     } catch (...) {
12299       {
12300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12301       };
12302     }
12303   }
12304
12305   jresult = (void *)result;
12306   return jresult;
12307 }
12308
12309
12310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12311   void * jresult ;
12312   Dali::Matrix *arg1 = 0 ;
12313   Dali::Matrix *result = 0 ;
12314
12315   arg1 = (Dali::Matrix *)jarg1;
12316   if (!arg1) {
12317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12318     return 0;
12319   }
12320   {
12321     try {
12322       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12323     } catch (std::out_of_range& e) {
12324       {
12325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (std::exception& e) {
12328       {
12329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (Dali::DaliException e) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12334       };
12335     } catch (...) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12338       };
12339     }
12340   }
12341
12342   jresult = (void *)result;
12343   return jresult;
12344 }
12345
12346
12347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12348   void * jresult ;
12349   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12350   Dali::Matrix *arg2 = 0 ;
12351   Dali::Matrix *result = 0 ;
12352
12353   arg1 = (Dali::Matrix *)jarg1;
12354   arg2 = (Dali::Matrix *)jarg2;
12355   if (!arg2) {
12356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12357     return 0;
12358   }
12359   {
12360     try {
12361       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12362     } catch (std::out_of_range& e) {
12363       {
12364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12365       };
12366     } catch (std::exception& e) {
12367       {
12368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12369       };
12370     } catch (Dali::DaliException e) {
12371       {
12372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12373       };
12374     } catch (...) {
12375       {
12376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12377       };
12378     }
12379   }
12380
12381   jresult = (void *)result;
12382   return jresult;
12383 }
12384
12385
12386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12387   void * jresult ;
12388   Dali::Matrix *result = 0 ;
12389
12390   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12391   jresult = (void *)result;
12392   return jresult;
12393 }
12394
12395
12396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12397   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12398
12399   arg1 = (Dali::Matrix *)jarg1;
12400   {
12401     try {
12402       (arg1)->SetIdentity();
12403     } catch (std::out_of_range& e) {
12404       {
12405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12406       };
12407     } catch (std::exception& e) {
12408       {
12409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12410       };
12411     } catch (Dali::DaliException e) {
12412       {
12413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12414       };
12415     } catch (...) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12418       };
12419     }
12420   }
12421
12422 }
12423
12424
12425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12426   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12427   Dali::Vector3 *arg2 = 0 ;
12428
12429   arg1 = (Dali::Matrix *)jarg1;
12430   arg2 = (Dali::Vector3 *)jarg2;
12431   if (!arg2) {
12432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12433     return ;
12434   }
12435   {
12436     try {
12437       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12438     } catch (std::out_of_range& e) {
12439       {
12440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12441       };
12442     } catch (std::exception& e) {
12443       {
12444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12445       };
12446     } catch (Dali::DaliException e) {
12447       {
12448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12449       };
12450     } catch (...) {
12451       {
12452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12453       };
12454     }
12455   }
12456
12457 }
12458
12459
12460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12461   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12462   Dali::Matrix *arg2 = 0 ;
12463
12464   arg1 = (Dali::Matrix *)jarg1;
12465   arg2 = (Dali::Matrix *)jarg2;
12466   if (!arg2) {
12467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12468     return ;
12469   }
12470   {
12471     try {
12472       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12473     } catch (std::out_of_range& e) {
12474       {
12475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12476       };
12477     } catch (std::exception& e) {
12478       {
12479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12480       };
12481     } catch (Dali::DaliException e) {
12482       {
12483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12484       };
12485     } catch (...) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12488       };
12489     }
12490   }
12491
12492 }
12493
12494
12495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12496   unsigned int jresult ;
12497   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12498   bool result;
12499
12500   arg1 = (Dali::Matrix *)jarg1;
12501   {
12502     try {
12503       result = (bool)(arg1)->Invert();
12504     } catch (std::out_of_range& e) {
12505       {
12506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12507       };
12508     } catch (std::exception& e) {
12509       {
12510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12511       };
12512     } catch (Dali::DaliException e) {
12513       {
12514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12515       };
12516     } catch (...) {
12517       {
12518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12519       };
12520     }
12521   }
12522
12523   jresult = result;
12524   return jresult;
12525 }
12526
12527
12528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12529   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12530
12531   arg1 = (Dali::Matrix *)jarg1;
12532   {
12533     try {
12534       (arg1)->Transpose();
12535     } catch (std::out_of_range& e) {
12536       {
12537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12538       };
12539     } catch (std::exception& e) {
12540       {
12541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12542       };
12543     } catch (Dali::DaliException e) {
12544       {
12545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12546       };
12547     } catch (...) {
12548       {
12549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12550       };
12551     }
12552   }
12553
12554 }
12555
12556
12557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12558   void * jresult ;
12559   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12560   Dali::Vector3 result;
12561
12562   arg1 = (Dali::Matrix *)jarg1;
12563   {
12564     try {
12565       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12566     } catch (std::out_of_range& e) {
12567       {
12568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12569       };
12570     } catch (std::exception& e) {
12571       {
12572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12573       };
12574     } catch (Dali::DaliException e) {
12575       {
12576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12577       };
12578     } catch (...) {
12579       {
12580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12581       };
12582     }
12583   }
12584
12585   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12586   return jresult;
12587 }
12588
12589
12590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12591   void * jresult ;
12592   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12593   Dali::Vector3 result;
12594
12595   arg1 = (Dali::Matrix *)jarg1;
12596   {
12597     try {
12598       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12599     } catch (std::out_of_range& e) {
12600       {
12601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12602       };
12603     } catch (std::exception& e) {
12604       {
12605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12606       };
12607     } catch (Dali::DaliException e) {
12608       {
12609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12610       };
12611     } catch (...) {
12612       {
12613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12614       };
12615     }
12616   }
12617
12618   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12619   return jresult;
12620 }
12621
12622
12623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12624   void * jresult ;
12625   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12626   Dali::Vector3 result;
12627
12628   arg1 = (Dali::Matrix *)jarg1;
12629   {
12630     try {
12631       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12632     } catch (std::out_of_range& e) {
12633       {
12634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12635       };
12636     } catch (std::exception& e) {
12637       {
12638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12639       };
12640     } catch (Dali::DaliException e) {
12641       {
12642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12643       };
12644     } catch (...) {
12645       {
12646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12647       };
12648     }
12649   }
12650
12651   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12652   return jresult;
12653 }
12654
12655
12656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12657   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12658   Dali::Vector3 *arg2 = 0 ;
12659
12660   arg1 = (Dali::Matrix *)jarg1;
12661   arg2 = (Dali::Vector3 *)jarg2;
12662   if (!arg2) {
12663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12664     return ;
12665   }
12666   {
12667     try {
12668       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12669     } catch (std::out_of_range& e) {
12670       {
12671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12672       };
12673     } catch (std::exception& e) {
12674       {
12675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12676       };
12677     } catch (Dali::DaliException e) {
12678       {
12679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12680       };
12681     } catch (...) {
12682       {
12683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12684       };
12685     }
12686   }
12687
12688 }
12689
12690
12691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12692   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12693   Dali::Vector3 *arg2 = 0 ;
12694
12695   arg1 = (Dali::Matrix *)jarg1;
12696   arg2 = (Dali::Vector3 *)jarg2;
12697   if (!arg2) {
12698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12699     return ;
12700   }
12701   {
12702     try {
12703       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12704     } catch (std::out_of_range& e) {
12705       {
12706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12707       };
12708     } catch (std::exception& e) {
12709       {
12710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12711       };
12712     } catch (Dali::DaliException e) {
12713       {
12714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12715       };
12716     } catch (...) {
12717       {
12718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12719       };
12720     }
12721   }
12722
12723 }
12724
12725
12726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12727   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12728   Dali::Vector3 *arg2 = 0 ;
12729
12730   arg1 = (Dali::Matrix *)jarg1;
12731   arg2 = (Dali::Vector3 *)jarg2;
12732   if (!arg2) {
12733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12734     return ;
12735   }
12736   {
12737     try {
12738       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12739     } catch (std::out_of_range& e) {
12740       {
12741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12742       };
12743     } catch (std::exception& e) {
12744       {
12745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12746       };
12747     } catch (Dali::DaliException e) {
12748       {
12749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12750       };
12751     } catch (...) {
12752       {
12753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12754       };
12755     }
12756   }
12757
12758 }
12759
12760
12761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12762   void * jresult ;
12763   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12764   Dali::Vector4 *result = 0 ;
12765
12766   arg1 = (Dali::Matrix *)jarg1;
12767   {
12768     try {
12769       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12770     } catch (std::out_of_range& e) {
12771       {
12772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12773       };
12774     } catch (std::exception& e) {
12775       {
12776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (Dali::DaliException e) {
12779       {
12780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12781       };
12782     } catch (...) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12785       };
12786     }
12787   }
12788
12789   jresult = (void *)result;
12790   return jresult;
12791 }
12792
12793
12794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12795   void * jresult ;
12796   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12797   Dali::Vector3 *result = 0 ;
12798
12799   arg1 = (Dali::Matrix *)jarg1;
12800   {
12801     try {
12802       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12803     } catch (std::out_of_range& e) {
12804       {
12805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12806       };
12807     } catch (std::exception& e) {
12808       {
12809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (Dali::DaliException e) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12814       };
12815     } catch (...) {
12816       {
12817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12818       };
12819     }
12820   }
12821
12822   jresult = (void *)result;
12823   return jresult;
12824 }
12825
12826
12827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12828   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12829   Dali::Vector4 *arg2 = 0 ;
12830
12831   arg1 = (Dali::Matrix *)jarg1;
12832   arg2 = (Dali::Vector4 *)jarg2;
12833   if (!arg2) {
12834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12835     return ;
12836   }
12837   {
12838     try {
12839       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12840     } catch (std::out_of_range& e) {
12841       {
12842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12843       };
12844     } catch (std::exception& e) {
12845       {
12846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12847       };
12848     } catch (Dali::DaliException e) {
12849       {
12850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12851       };
12852     } catch (...) {
12853       {
12854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12855       };
12856     }
12857   }
12858
12859 }
12860
12861
12862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12863   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12864   Dali::Vector3 *arg2 = 0 ;
12865
12866   arg1 = (Dali::Matrix *)jarg1;
12867   arg2 = (Dali::Vector3 *)jarg2;
12868   if (!arg2) {
12869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12870     return ;
12871   }
12872   {
12873     try {
12874       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12875     } catch (std::out_of_range& e) {
12876       {
12877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12878       };
12879     } catch (std::exception& e) {
12880       {
12881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12882       };
12883     } catch (Dali::DaliException e) {
12884       {
12885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12886       };
12887     } catch (...) {
12888       {
12889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12890       };
12891     }
12892   }
12893
12894 }
12895
12896
12897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12898   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12899
12900   arg1 = (Dali::Matrix *)jarg1;
12901   {
12902     try {
12903       (arg1)->OrthoNormalize();
12904     } catch (std::out_of_range& e) {
12905       {
12906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12907       };
12908     } catch (std::exception& e) {
12909       {
12910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12911       };
12912     } catch (Dali::DaliException e) {
12913       {
12914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12915       };
12916     } catch (...) {
12917       {
12918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12919       };
12920     }
12921   }
12922
12923 }
12924
12925
12926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12927   void * jresult ;
12928   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12929   float *result = 0 ;
12930
12931   arg1 = (Dali::Matrix *)jarg1;
12932   {
12933     try {
12934       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12935     } catch (std::out_of_range& e) {
12936       {
12937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12938       };
12939     } catch (std::exception& e) {
12940       {
12941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12942       };
12943     } catch (Dali::DaliException e) {
12944       {
12945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12946       };
12947     } catch (...) {
12948       {
12949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12950       };
12951     }
12952   }
12953
12954   jresult = (void *)result;
12955   return jresult;
12956 }
12957
12958
12959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12960   Dali::Matrix *arg1 = 0 ;
12961   Dali::Matrix *arg2 = 0 ;
12962   Dali::Matrix *arg3 = 0 ;
12963
12964   arg1 = (Dali::Matrix *)jarg1;
12965   if (!arg1) {
12966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12967     return ;
12968   }
12969   arg2 = (Dali::Matrix *)jarg2;
12970   if (!arg2) {
12971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12972     return ;
12973   }
12974   arg3 = (Dali::Matrix *)jarg3;
12975   if (!arg3) {
12976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12977     return ;
12978   }
12979   {
12980     try {
12981       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12982     } catch (std::out_of_range& e) {
12983       {
12984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12985       };
12986     } catch (std::exception& e) {
12987       {
12988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12989       };
12990     } catch (Dali::DaliException e) {
12991       {
12992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12993       };
12994     } catch (...) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12997       };
12998     }
12999   }
13000
13001 }
13002
13003
13004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13005   Dali::Matrix *arg1 = 0 ;
13006   Dali::Matrix *arg2 = 0 ;
13007   Dali::Quaternion *arg3 = 0 ;
13008
13009   arg1 = (Dali::Matrix *)jarg1;
13010   if (!arg1) {
13011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13012     return ;
13013   }
13014   arg2 = (Dali::Matrix *)jarg2;
13015   if (!arg2) {
13016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13017     return ;
13018   }
13019   arg3 = (Dali::Quaternion *)jarg3;
13020   if (!arg3) {
13021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13022     return ;
13023   }
13024   {
13025     try {
13026       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13027     } catch (std::out_of_range& e) {
13028       {
13029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13030       };
13031     } catch (std::exception& e) {
13032       {
13033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13034       };
13035     } catch (Dali::DaliException e) {
13036       {
13037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13038       };
13039     } catch (...) {
13040       {
13041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13042       };
13043     }
13044   }
13045
13046 }
13047
13048
13049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13050   void * jresult ;
13051   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13052   Dali::Vector4 *arg2 = 0 ;
13053   Dali::Vector4 result;
13054
13055   arg1 = (Dali::Matrix *)jarg1;
13056   arg2 = (Dali::Vector4 *)jarg2;
13057   if (!arg2) {
13058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13059     return 0;
13060   }
13061   {
13062     try {
13063       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13064     } catch (std::out_of_range& e) {
13065       {
13066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13067       };
13068     } catch (std::exception& e) {
13069       {
13070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (Dali::DaliException e) {
13073       {
13074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13075       };
13076     } catch (...) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13079       };
13080     }
13081   }
13082
13083   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13084   return jresult;
13085 }
13086
13087
13088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13089   unsigned int jresult ;
13090   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13091   Dali::Matrix *arg2 = 0 ;
13092   bool result;
13093
13094   arg1 = (Dali::Matrix *)jarg1;
13095   arg2 = (Dali::Matrix *)jarg2;
13096   if (!arg2) {
13097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13098     return 0;
13099   }
13100   {
13101     try {
13102       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13103     } catch (std::out_of_range& e) {
13104       {
13105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13106       };
13107     } catch (std::exception& e) {
13108       {
13109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (Dali::DaliException e) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13114       };
13115     } catch (...) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13118       };
13119     }
13120   }
13121
13122   jresult = result;
13123   return jresult;
13124 }
13125
13126
13127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13128   unsigned int jresult ;
13129   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13130   Dali::Matrix *arg2 = 0 ;
13131   bool result;
13132
13133   arg1 = (Dali::Matrix *)jarg1;
13134   arg2 = (Dali::Matrix *)jarg2;
13135   if (!arg2) {
13136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13137     return 0;
13138   }
13139   {
13140     try {
13141       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13142     } catch (std::out_of_range& e) {
13143       {
13144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13145       };
13146     } catch (std::exception& e) {
13147       {
13148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13149       };
13150     } catch (Dali::DaliException e) {
13151       {
13152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13153       };
13154     } catch (...) {
13155       {
13156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13157       };
13158     }
13159   }
13160
13161   jresult = result;
13162   return jresult;
13163 }
13164
13165
13166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13167   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13168   Dali::Vector3 *arg2 = 0 ;
13169   Dali::Quaternion *arg3 = 0 ;
13170   Dali::Vector3 *arg4 = 0 ;
13171
13172   arg1 = (Dali::Matrix *)jarg1;
13173   arg2 = (Dali::Vector3 *)jarg2;
13174   if (!arg2) {
13175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13176     return ;
13177   }
13178   arg3 = (Dali::Quaternion *)jarg3;
13179   if (!arg3) {
13180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13181     return ;
13182   }
13183   arg4 = (Dali::Vector3 *)jarg4;
13184   if (!arg4) {
13185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13186     return ;
13187   }
13188   {
13189     try {
13190       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13191     } catch (std::out_of_range& e) {
13192       {
13193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13194       };
13195     } catch (std::exception& e) {
13196       {
13197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13198       };
13199     } catch (Dali::DaliException e) {
13200       {
13201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13202       };
13203     } catch (...) {
13204       {
13205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13206       };
13207     }
13208   }
13209
13210 }
13211
13212
13213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13214   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13215   Dali::Vector3 *arg2 = 0 ;
13216   Dali::Quaternion *arg3 = 0 ;
13217   Dali::Vector3 *arg4 = 0 ;
13218
13219   arg1 = (Dali::Matrix *)jarg1;
13220   arg2 = (Dali::Vector3 *)jarg2;
13221   if (!arg2) {
13222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13223     return ;
13224   }
13225   arg3 = (Dali::Quaternion *)jarg3;
13226   if (!arg3) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13228     return ;
13229   }
13230   arg4 = (Dali::Vector3 *)jarg4;
13231   if (!arg4) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13233     return ;
13234   }
13235   {
13236     try {
13237       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13238     } catch (std::out_of_range& e) {
13239       {
13240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13241       };
13242     } catch (std::exception& e) {
13243       {
13244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13245       };
13246     } catch (Dali::DaliException e) {
13247       {
13248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13249       };
13250     } catch (...) {
13251       {
13252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13253       };
13254     }
13255   }
13256
13257 }
13258
13259
13260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13261   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13262   Dali::Vector3 *arg2 = 0 ;
13263   Dali::Vector3 *arg3 = 0 ;
13264   Dali::Vector3 *arg4 = 0 ;
13265   Dali::Vector3 *arg5 = 0 ;
13266
13267   arg1 = (Dali::Matrix *)jarg1;
13268   arg2 = (Dali::Vector3 *)jarg2;
13269   if (!arg2) {
13270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13271     return ;
13272   }
13273   arg3 = (Dali::Vector3 *)jarg3;
13274   if (!arg3) {
13275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13276     return ;
13277   }
13278   arg4 = (Dali::Vector3 *)jarg4;
13279   if (!arg4) {
13280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13281     return ;
13282   }
13283   arg5 = (Dali::Vector3 *)jarg5;
13284   if (!arg5) {
13285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13286     return ;
13287   }
13288   {
13289     try {
13290       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13291     } catch (std::out_of_range& e) {
13292       {
13293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13294       };
13295     } catch (std::exception& e) {
13296       {
13297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13298       };
13299     } catch (Dali::DaliException e) {
13300       {
13301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13302       };
13303     } catch (...) {
13304       {
13305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13306       };
13307     }
13308   }
13309
13310 }
13311
13312
13313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13314   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13315   Dali::Vector3 *arg2 = 0 ;
13316   Dali::Quaternion *arg3 = 0 ;
13317   Dali::Vector3 *arg4 = 0 ;
13318
13319   arg1 = (Dali::Matrix *)jarg1;
13320   arg2 = (Dali::Vector3 *)jarg2;
13321   if (!arg2) {
13322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13323     return ;
13324   }
13325   arg3 = (Dali::Quaternion *)jarg3;
13326   if (!arg3) {
13327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13328     return ;
13329   }
13330   arg4 = (Dali::Vector3 *)jarg4;
13331   if (!arg4) {
13332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13333     return ;
13334   }
13335   {
13336     try {
13337       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13338     } catch (std::out_of_range& e) {
13339       {
13340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13341       };
13342     } catch (std::exception& e) {
13343       {
13344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (Dali::DaliException e) {
13347       {
13348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13349       };
13350     } catch (...) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13353       };
13354     }
13355   }
13356
13357 }
13358
13359
13360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13361   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13362
13363   arg1 = (Dali::Matrix *)jarg1;
13364   {
13365     try {
13366       delete arg1;
13367     } catch (std::out_of_range& e) {
13368       {
13369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13370       };
13371     } catch (std::exception& e) {
13372       {
13373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (Dali::DaliException e) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13378       };
13379     } catch (...) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13382       };
13383     }
13384   }
13385
13386 }
13387
13388
13389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13390   void * jresult ;
13391   Dali::Matrix3 *result = 0 ;
13392
13393   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13394   jresult = (void *)result;
13395   return jresult;
13396 }
13397
13398
13399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13400   void * jresult ;
13401   Dali::Matrix3 *result = 0 ;
13402
13403   {
13404     try {
13405       result = (Dali::Matrix3 *)new Dali::Matrix3();
13406     } catch (std::out_of_range& e) {
13407       {
13408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13409       };
13410     } catch (std::exception& e) {
13411       {
13412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13413       };
13414     } catch (Dali::DaliException e) {
13415       {
13416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13417       };
13418     } catch (...) {
13419       {
13420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13421       };
13422     }
13423   }
13424
13425   jresult = (void *)result;
13426   return jresult;
13427 }
13428
13429
13430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13431   void * jresult ;
13432   Dali::Matrix3 *arg1 = 0 ;
13433   Dali::Matrix3 *result = 0 ;
13434
13435   arg1 = (Dali::Matrix3 *)jarg1;
13436   if (!arg1) {
13437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13438     return 0;
13439   }
13440   {
13441     try {
13442       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13443     } catch (std::out_of_range& e) {
13444       {
13445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13446       };
13447     } catch (std::exception& e) {
13448       {
13449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13450       };
13451     } catch (Dali::DaliException e) {
13452       {
13453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13454       };
13455     } catch (...) {
13456       {
13457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13458       };
13459     }
13460   }
13461
13462   jresult = (void *)result;
13463   return jresult;
13464 }
13465
13466
13467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13468   void * jresult ;
13469   Dali::Matrix *arg1 = 0 ;
13470   Dali::Matrix3 *result = 0 ;
13471
13472   arg1 = (Dali::Matrix *)jarg1;
13473   if (!arg1) {
13474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13475     return 0;
13476   }
13477   {
13478     try {
13479       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13480     } catch (std::out_of_range& e) {
13481       {
13482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13483       };
13484     } catch (std::exception& e) {
13485       {
13486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13487       };
13488     } catch (Dali::DaliException e) {
13489       {
13490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13491       };
13492     } catch (...) {
13493       {
13494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13495       };
13496     }
13497   }
13498
13499   jresult = (void *)result;
13500   return jresult;
13501 }
13502
13503
13504 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) {
13505   void * jresult ;
13506   float arg1 ;
13507   float arg2 ;
13508   float arg3 ;
13509   float arg4 ;
13510   float arg5 ;
13511   float arg6 ;
13512   float arg7 ;
13513   float arg8 ;
13514   float arg9 ;
13515   Dali::Matrix3 *result = 0 ;
13516
13517   arg1 = (float)jarg1;
13518   arg2 = (float)jarg2;
13519   arg3 = (float)jarg3;
13520   arg4 = (float)jarg4;
13521   arg5 = (float)jarg5;
13522   arg6 = (float)jarg6;
13523   arg7 = (float)jarg7;
13524   arg8 = (float)jarg8;
13525   arg9 = (float)jarg9;
13526   {
13527     try {
13528       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13529     } catch (std::out_of_range& e) {
13530       {
13531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (std::exception& e) {
13534       {
13535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (Dali::DaliException e) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13540       };
13541     } catch (...) {
13542       {
13543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13544       };
13545     }
13546   }
13547
13548   jresult = (void *)result;
13549   return jresult;
13550 }
13551
13552
13553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13554   void * jresult ;
13555   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13556   Dali::Matrix3 *arg2 = 0 ;
13557   Dali::Matrix3 *result = 0 ;
13558
13559   arg1 = (Dali::Matrix3 *)jarg1;
13560   arg2 = (Dali::Matrix3 *)jarg2;
13561   if (!arg2) {
13562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13563     return 0;
13564   }
13565   {
13566     try {
13567       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13568     } catch (std::out_of_range& e) {
13569       {
13570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (std::exception& e) {
13573       {
13574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (Dali::DaliException e) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13579       };
13580     } catch (...) {
13581       {
13582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13583       };
13584     }
13585   }
13586
13587   jresult = (void *)result;
13588   return jresult;
13589 }
13590
13591
13592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13593   void * jresult ;
13594   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13595   Dali::Matrix *arg2 = 0 ;
13596   Dali::Matrix3 *result = 0 ;
13597
13598   arg1 = (Dali::Matrix3 *)jarg1;
13599   arg2 = (Dali::Matrix *)jarg2;
13600   if (!arg2) {
13601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13602     return 0;
13603   }
13604   {
13605     try {
13606       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13607     } catch (std::out_of_range& e) {
13608       {
13609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13610       };
13611     } catch (std::exception& e) {
13612       {
13613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (Dali::DaliException e) {
13616       {
13617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13618       };
13619     } catch (...) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13622       };
13623     }
13624   }
13625
13626   jresult = (void *)result;
13627   return jresult;
13628 }
13629
13630
13631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13632   unsigned int jresult ;
13633   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13634   Dali::Matrix3 *arg2 = 0 ;
13635   bool result;
13636
13637   arg1 = (Dali::Matrix3 *)jarg1;
13638   arg2 = (Dali::Matrix3 *)jarg2;
13639   if (!arg2) {
13640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13641     return 0;
13642   }
13643   {
13644     try {
13645       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13646     } catch (std::out_of_range& e) {
13647       {
13648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (std::exception& e) {
13651       {
13652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13653       };
13654     } catch (Dali::DaliException e) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13657       };
13658     } catch (...) {
13659       {
13660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13661       };
13662     }
13663   }
13664
13665   jresult = result;
13666   return jresult;
13667 }
13668
13669
13670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13671   unsigned int jresult ;
13672   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13673   Dali::Matrix3 *arg2 = 0 ;
13674   bool result;
13675
13676   arg1 = (Dali::Matrix3 *)jarg1;
13677   arg2 = (Dali::Matrix3 *)jarg2;
13678   if (!arg2) {
13679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13680     return 0;
13681   }
13682   {
13683     try {
13684       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13685     } catch (std::out_of_range& e) {
13686       {
13687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13688       };
13689     } catch (std::exception& e) {
13690       {
13691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13692       };
13693     } catch (Dali::DaliException e) {
13694       {
13695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13696       };
13697     } catch (...) {
13698       {
13699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13700       };
13701     }
13702   }
13703
13704   jresult = result;
13705   return jresult;
13706 }
13707
13708
13709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13710   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13711
13712   arg1 = (Dali::Matrix3 *)jarg1;
13713   {
13714     try {
13715       delete arg1;
13716     } catch (std::out_of_range& e) {
13717       {
13718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13719       };
13720     } catch (std::exception& e) {
13721       {
13722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13723       };
13724     } catch (Dali::DaliException e) {
13725       {
13726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13727       };
13728     } catch (...) {
13729       {
13730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13731       };
13732     }
13733   }
13734
13735 }
13736
13737
13738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13739   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13740
13741   arg1 = (Dali::Matrix3 *)jarg1;
13742   {
13743     try {
13744       (arg1)->SetIdentity();
13745     } catch (std::out_of_range& e) {
13746       {
13747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13748       };
13749     } catch (std::exception& e) {
13750       {
13751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13752       };
13753     } catch (Dali::DaliException e) {
13754       {
13755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13756       };
13757     } catch (...) {
13758       {
13759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13760       };
13761     }
13762   }
13763
13764 }
13765
13766
13767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13768   void * jresult ;
13769   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13770   float *result = 0 ;
13771
13772   arg1 = (Dali::Matrix3 *)jarg1;
13773   {
13774     try {
13775       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13776     } catch (std::out_of_range& e) {
13777       {
13778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13779       };
13780     } catch (std::exception& e) {
13781       {
13782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13783       };
13784     } catch (Dali::DaliException e) {
13785       {
13786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13787       };
13788     } catch (...) {
13789       {
13790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13791       };
13792     }
13793   }
13794
13795   jresult = (void *)result;
13796   return jresult;
13797 }
13798
13799
13800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13801   unsigned int jresult ;
13802   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13803   bool result;
13804
13805   arg1 = (Dali::Matrix3 *)jarg1;
13806   {
13807     try {
13808       result = (bool)(arg1)->Invert();
13809     } catch (std::out_of_range& e) {
13810       {
13811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13812       };
13813     } catch (std::exception& e) {
13814       {
13815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13816       };
13817     } catch (Dali::DaliException e) {
13818       {
13819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13820       };
13821     } catch (...) {
13822       {
13823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13824       };
13825     }
13826   }
13827
13828   jresult = result;
13829   return jresult;
13830 }
13831
13832
13833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13834   unsigned int jresult ;
13835   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13836   bool result;
13837
13838   arg1 = (Dali::Matrix3 *)jarg1;
13839   {
13840     try {
13841       result = (bool)(arg1)->Transpose();
13842     } catch (std::out_of_range& e) {
13843       {
13844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13845       };
13846     } catch (std::exception& e) {
13847       {
13848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13849       };
13850     } catch (Dali::DaliException e) {
13851       {
13852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13853       };
13854     } catch (...) {
13855       {
13856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13857       };
13858     }
13859   }
13860
13861   jresult = result;
13862   return jresult;
13863 }
13864
13865
13866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13867   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13868   float arg2 ;
13869
13870   arg1 = (Dali::Matrix3 *)jarg1;
13871   arg2 = (float)jarg2;
13872   {
13873     try {
13874       (arg1)->Scale(arg2);
13875     } catch (std::out_of_range& e) {
13876       {
13877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13878       };
13879     } catch (std::exception& e) {
13880       {
13881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13882       };
13883     } catch (Dali::DaliException e) {
13884       {
13885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13886       };
13887     } catch (...) {
13888       {
13889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13890       };
13891     }
13892   }
13893
13894 }
13895
13896
13897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13898   float jresult ;
13899   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13900   float result;
13901
13902   arg1 = (Dali::Matrix3 *)jarg1;
13903   {
13904     try {
13905       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13906     } catch (std::out_of_range& e) {
13907       {
13908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13909       };
13910     } catch (std::exception& e) {
13911       {
13912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13913       };
13914     } catch (Dali::DaliException e) {
13915       {
13916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13917       };
13918     } catch (...) {
13919       {
13920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13921       };
13922     }
13923   }
13924
13925   jresult = result;
13926   return jresult;
13927 }
13928
13929
13930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13931   unsigned int jresult ;
13932   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13933   bool result;
13934
13935   arg1 = (Dali::Matrix3 *)jarg1;
13936   {
13937     try {
13938       result = (bool)(arg1)->ScaledInverseTranspose();
13939     } catch (std::out_of_range& e) {
13940       {
13941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13942       };
13943     } catch (std::exception& e) {
13944       {
13945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13946       };
13947     } catch (Dali::DaliException e) {
13948       {
13949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13950       };
13951     } catch (...) {
13952       {
13953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13954       };
13955     }
13956   }
13957
13958   jresult = result;
13959   return jresult;
13960 }
13961
13962
13963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13964   Dali::Matrix3 *arg1 = 0 ;
13965   Dali::Matrix3 *arg2 = 0 ;
13966   Dali::Matrix3 *arg3 = 0 ;
13967
13968   arg1 = (Dali::Matrix3 *)jarg1;
13969   if (!arg1) {
13970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13971     return ;
13972   }
13973   arg2 = (Dali::Matrix3 *)jarg2;
13974   if (!arg2) {
13975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13976     return ;
13977   }
13978   arg3 = (Dali::Matrix3 *)jarg3;
13979   if (!arg3) {
13980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13981     return ;
13982   }
13983   {
13984     try {
13985       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13986     } catch (std::out_of_range& e) {
13987       {
13988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13989       };
13990     } catch (std::exception& e) {
13991       {
13992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13993       };
13994     } catch (Dali::DaliException e) {
13995       {
13996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13997       };
13998     } catch (...) {
13999       {
14000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14001       };
14002     }
14003   }
14004
14005 }
14006
14007
14008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14009   float jresult ;
14010   float arg1 ;
14011   float arg2 ;
14012   float result;
14013
14014   arg1 = (float)jarg1;
14015   arg2 = (float)jarg2;
14016   {
14017     try {
14018       result = (float)Dali::Random::Range(arg1,arg2);
14019     } catch (std::out_of_range& e) {
14020       {
14021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14022       };
14023     } catch (std::exception& e) {
14024       {
14025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (Dali::DaliException e) {
14028       {
14029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14030       };
14031     } catch (...) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14034       };
14035     }
14036   }
14037
14038   jresult = result;
14039   return jresult;
14040 }
14041
14042
14043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14044   void * jresult ;
14045   Dali::Vector4 result;
14046
14047   {
14048     try {
14049       result = Dali::Random::Axis();
14050     } catch (std::out_of_range& e) {
14051       {
14052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14053       };
14054     } catch (std::exception& e) {
14055       {
14056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (Dali::DaliException e) {
14059       {
14060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14061       };
14062     } catch (...) {
14063       {
14064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14065       };
14066     }
14067   }
14068
14069   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14070   return jresult;
14071 }
14072
14073
14074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14075   void * jresult ;
14076   Dali::AngleAxis *result = 0 ;
14077
14078   {
14079     try {
14080       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14081     } catch (std::out_of_range& e) {
14082       {
14083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14084       };
14085     } catch (std::exception& e) {
14086       {
14087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (Dali::DaliException e) {
14090       {
14091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14092       };
14093     } catch (...) {
14094       {
14095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14096       };
14097     }
14098   }
14099
14100   jresult = (void *)result;
14101   return jresult;
14102 }
14103
14104
14105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14106   void * jresult ;
14107   Dali::Radian arg1 ;
14108   Dali::Vector3 *arg2 = 0 ;
14109   Dali::Radian *argp1 ;
14110   Dali::AngleAxis *result = 0 ;
14111
14112   argp1 = (Dali::Radian *)jarg1;
14113   if (!argp1) {
14114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14115     return 0;
14116   }
14117   arg1 = *argp1;
14118   arg2 = (Dali::Vector3 *)jarg2;
14119   if (!arg2) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14121     return 0;
14122   }
14123   {
14124     try {
14125       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14126     } catch (std::out_of_range& e) {
14127       {
14128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14129       };
14130     } catch (std::exception& e) {
14131       {
14132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14133       };
14134     } catch (Dali::DaliException e) {
14135       {
14136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14137       };
14138     } catch (...) {
14139       {
14140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14141       };
14142     }
14143   }
14144
14145   jresult = (void *)result;
14146   return jresult;
14147 }
14148
14149
14150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14151   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14152   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14153
14154   arg1 = (Dali::AngleAxis *)jarg1;
14155   arg2 = (Dali::Radian *)jarg2;
14156   if (arg1) (arg1)->angle = *arg2;
14157 }
14158
14159
14160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14161   void * jresult ;
14162   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14163   Dali::Radian *result = 0 ;
14164
14165   arg1 = (Dali::AngleAxis *)jarg1;
14166   result = (Dali::Radian *)& ((arg1)->angle);
14167   jresult = (void *)result;
14168   return jresult;
14169 }
14170
14171
14172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14173   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14174   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14175
14176   arg1 = (Dali::AngleAxis *)jarg1;
14177   arg2 = (Dali::Vector3 *)jarg2;
14178   if (arg1) (arg1)->axis = *arg2;
14179 }
14180
14181
14182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14183   void * jresult ;
14184   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14185   Dali::Vector3 *result = 0 ;
14186
14187   arg1 = (Dali::AngleAxis *)jarg1;
14188   result = (Dali::Vector3 *)& ((arg1)->axis);
14189   jresult = (void *)result;
14190   return jresult;
14191 }
14192
14193
14194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14195   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14196
14197   arg1 = (Dali::AngleAxis *)jarg1;
14198   {
14199     try {
14200       delete arg1;
14201     } catch (std::out_of_range& e) {
14202       {
14203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14204       };
14205     } catch (std::exception& e) {
14206       {
14207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14208       };
14209     } catch (Dali::DaliException e) {
14210       {
14211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14212       };
14213     } catch (...) {
14214       {
14215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14216       };
14217     }
14218   }
14219
14220 }
14221
14222
14223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14224   unsigned int jresult ;
14225   Dali::AngleAxis *arg1 = 0 ;
14226   Dali::AngleAxis *arg2 = 0 ;
14227   bool result;
14228
14229   arg1 = (Dali::AngleAxis *)jarg1;
14230   if (!arg1) {
14231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14232     return 0;
14233   }
14234   arg2 = (Dali::AngleAxis *)jarg2;
14235   if (!arg2) {
14236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14237     return 0;
14238   }
14239   {
14240     try {
14241       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14242     } catch (std::out_of_range& e) {
14243       {
14244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14245       };
14246     } catch (std::exception& e) {
14247       {
14248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14249       };
14250     } catch (Dali::DaliException e) {
14251       {
14252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14253       };
14254     } catch (...) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14257       };
14258     }
14259   }
14260
14261   jresult = result;
14262   return jresult;
14263 }
14264
14265
14266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14267   unsigned int jresult ;
14268   unsigned int arg1 ;
14269   unsigned int result;
14270
14271   arg1 = (unsigned int)jarg1;
14272   {
14273     try {
14274       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14275     } catch (std::out_of_range& e) {
14276       {
14277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14278       };
14279     } catch (std::exception& e) {
14280       {
14281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (Dali::DaliException e) {
14284       {
14285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14286       };
14287     } catch (...) {
14288       {
14289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14290       };
14291     }
14292   }
14293
14294   jresult = result;
14295   return jresult;
14296 }
14297
14298
14299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14300   unsigned int jresult ;
14301   unsigned int arg1 ;
14302   bool result;
14303
14304   arg1 = (unsigned int)jarg1;
14305   {
14306     try {
14307       result = (bool)Dali::IsPowerOfTwo(arg1);
14308     } catch (std::out_of_range& e) {
14309       {
14310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14311       };
14312     } catch (std::exception& e) {
14313       {
14314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14315       };
14316     } catch (Dali::DaliException e) {
14317       {
14318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14319       };
14320     } catch (...) {
14321       {
14322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14323       };
14324     }
14325   }
14326
14327   jresult = result;
14328   return jresult;
14329 }
14330
14331
14332 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14333   float jresult ;
14334   float arg1 ;
14335   float arg2 ;
14336   float result;
14337
14338   arg1 = (float)jarg1;
14339   arg2 = (float)jarg2;
14340   {
14341     try {
14342       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14343     } catch (std::out_of_range& e) {
14344       {
14345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14346       };
14347     } catch (std::exception& e) {
14348       {
14349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14350       };
14351     } catch (Dali::DaliException e) {
14352       {
14353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14354       };
14355     } catch (...) {
14356       {
14357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14358       };
14359     }
14360   }
14361
14362   jresult = result;
14363   return jresult;
14364 }
14365
14366
14367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14368   unsigned int jresult ;
14369   float arg1 ;
14370   bool result;
14371
14372   arg1 = (float)jarg1;
14373   {
14374     try {
14375       result = (bool)Dali::EqualsZero(arg1);
14376     } catch (std::out_of_range& e) {
14377       {
14378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14379       };
14380     } catch (std::exception& e) {
14381       {
14382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14383       };
14384     } catch (Dali::DaliException e) {
14385       {
14386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14387       };
14388     } catch (...) {
14389       {
14390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14391       };
14392     }
14393   }
14394
14395   jresult = result;
14396   return jresult;
14397 }
14398
14399
14400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14401   unsigned int jresult ;
14402   float arg1 ;
14403   float arg2 ;
14404   bool result;
14405
14406   arg1 = (float)jarg1;
14407   arg2 = (float)jarg2;
14408   {
14409     try {
14410       result = (bool)Dali::Equals(arg1,arg2);
14411     } catch (std::out_of_range& e) {
14412       {
14413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14414       };
14415     } catch (std::exception& e) {
14416       {
14417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (Dali::DaliException e) {
14420       {
14421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14422       };
14423     } catch (...) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14426       };
14427     }
14428   }
14429
14430   jresult = result;
14431   return jresult;
14432 }
14433
14434
14435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14436   unsigned int jresult ;
14437   float arg1 ;
14438   float arg2 ;
14439   float arg3 ;
14440   bool result;
14441
14442   arg1 = (float)jarg1;
14443   arg2 = (float)jarg2;
14444   arg3 = (float)jarg3;
14445   {
14446     try {
14447       result = (bool)Dali::Equals(arg1,arg2,arg3);
14448     } catch (std::out_of_range& e) {
14449       {
14450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14451       };
14452     } catch (std::exception& e) {
14453       {
14454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (Dali::DaliException e) {
14457       {
14458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14459       };
14460     } catch (...) {
14461       {
14462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14463       };
14464     }
14465   }
14466
14467   jresult = result;
14468   return jresult;
14469 }
14470
14471
14472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14473   float jresult ;
14474   float arg1 ;
14475   int arg2 ;
14476   float result;
14477
14478   arg1 = (float)jarg1;
14479   arg2 = (int)jarg2;
14480   {
14481     try {
14482       result = (float)Dali::Round(arg1,arg2);
14483     } catch (std::out_of_range& e) {
14484       {
14485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14486       };
14487     } catch (std::exception& e) {
14488       {
14489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14490       };
14491     } catch (Dali::DaliException e) {
14492       {
14493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14494       };
14495     } catch (...) {
14496       {
14497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14498       };
14499     }
14500   }
14501
14502   jresult = result;
14503   return jresult;
14504 }
14505
14506
14507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14508   float jresult ;
14509   float arg1 ;
14510   float arg2 ;
14511   float arg3 ;
14512   float result;
14513
14514   arg1 = (float)jarg1;
14515   arg2 = (float)jarg2;
14516   arg3 = (float)jarg3;
14517   {
14518     try {
14519       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14520     } catch (std::out_of_range& e) {
14521       {
14522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14523       };
14524     } catch (std::exception& e) {
14525       {
14526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14527       };
14528     } catch (Dali::DaliException e) {
14529       {
14530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14531       };
14532     } catch (...) {
14533       {
14534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14535       };
14536     }
14537   }
14538
14539   jresult = result;
14540   return jresult;
14541 }
14542
14543
14544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14545   float jresult ;
14546   float arg1 ;
14547   float arg2 ;
14548   float arg3 ;
14549   float arg4 ;
14550   float result;
14551
14552   arg1 = (float)jarg1;
14553   arg2 = (float)jarg2;
14554   arg3 = (float)jarg3;
14555   arg4 = (float)jarg4;
14556   {
14557     try {
14558       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14559     } catch (std::out_of_range& e) {
14560       {
14561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14562       };
14563     } catch (std::exception& e) {
14564       {
14565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14566       };
14567     } catch (Dali::DaliException e) {
14568       {
14569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14570       };
14571     } catch (...) {
14572       {
14573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14574       };
14575     }
14576   }
14577
14578   jresult = result;
14579   return jresult;
14580 }
14581
14582
14583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14584   int jresult ;
14585   int result;
14586
14587   result = (int)(int)Dali::Property::INVALID_INDEX;
14588   jresult = result;
14589   return jresult;
14590 }
14591
14592
14593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14594   int jresult ;
14595   int result;
14596
14597   result = (int)(int)Dali::Property::INVALID_KEY;
14598   jresult = result;
14599   return jresult;
14600 }
14601
14602
14603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14604   int jresult ;
14605   int result;
14606
14607   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14608   jresult = result;
14609   return jresult;
14610 }
14611
14612
14613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14614   void * jresult ;
14615   Dali::Handle *arg1 = 0 ;
14616   Dali::Property::Index arg2 ;
14617   Dali::Property *result = 0 ;
14618
14619   arg1 = (Dali::Handle *)jarg1;
14620   if (!arg1) {
14621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14622     return 0;
14623   }
14624   arg2 = (Dali::Property::Index)jarg2;
14625   {
14626     try {
14627       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (Dali::DaliException e) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646
14647   jresult = (void *)result;
14648   return jresult;
14649 }
14650
14651
14652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14653   void * jresult ;
14654   Dali::Handle *arg1 = 0 ;
14655   Dali::Property::Index arg2 ;
14656   int arg3 ;
14657   Dali::Property *result = 0 ;
14658
14659   arg1 = (Dali::Handle *)jarg1;
14660   if (!arg1) {
14661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14662     return 0;
14663   }
14664   arg2 = (Dali::Property::Index)jarg2;
14665   arg3 = (int)jarg3;
14666   {
14667     try {
14668       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14669     } catch (std::out_of_range& e) {
14670       {
14671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14672       };
14673     } catch (std::exception& e) {
14674       {
14675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14676       };
14677     } catch (Dali::DaliException e) {
14678       {
14679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14680       };
14681     } catch (...) {
14682       {
14683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14684       };
14685     }
14686   }
14687
14688   jresult = (void *)result;
14689   return jresult;
14690 }
14691
14692
14693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14694   void * jresult ;
14695   Dali::Handle *arg1 = 0 ;
14696   std::string *arg2 = 0 ;
14697   Dali::Property *result = 0 ;
14698
14699   arg1 = (Dali::Handle *)jarg1;
14700   if (!arg1) {
14701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14702     return 0;
14703   }
14704   if (!jarg2) {
14705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14706     return 0;
14707   }
14708   std::string arg2_str(jarg2);
14709   arg2 = &arg2_str;
14710   {
14711     try {
14712       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14713     } catch (std::out_of_range& e) {
14714       {
14715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14716       };
14717     } catch (std::exception& e) {
14718       {
14719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14720       };
14721     } catch (Dali::DaliException e) {
14722       {
14723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14724       };
14725     } catch (...) {
14726       {
14727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14728       };
14729     }
14730   }
14731
14732   jresult = (void *)result;
14733
14734   //argout typemap for const std::string&
14735
14736   return jresult;
14737 }
14738
14739
14740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14741   void * jresult ;
14742   Dali::Handle *arg1 = 0 ;
14743   std::string *arg2 = 0 ;
14744   int arg3 ;
14745   Dali::Property *result = 0 ;
14746
14747   arg1 = (Dali::Handle *)jarg1;
14748   if (!arg1) {
14749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14750     return 0;
14751   }
14752   if (!jarg2) {
14753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14754     return 0;
14755   }
14756   std::string arg2_str(jarg2);
14757   arg2 = &arg2_str;
14758   arg3 = (int)jarg3;
14759   {
14760     try {
14761       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14762     } catch (std::out_of_range& e) {
14763       {
14764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14765       };
14766     } catch (std::exception& e) {
14767       {
14768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (Dali::DaliException e) {
14771       {
14772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14773       };
14774     } catch (...) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14777       };
14778     }
14779   }
14780
14781   jresult = (void *)result;
14782
14783   //argout typemap for const std::string&
14784
14785   return jresult;
14786 }
14787
14788
14789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14790   Dali::Property *arg1 = (Dali::Property *) 0 ;
14791
14792   arg1 = (Dali::Property *)jarg1;
14793   {
14794     try {
14795       delete arg1;
14796     } catch (std::out_of_range& e) {
14797       {
14798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14799       };
14800     } catch (std::exception& e) {
14801       {
14802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14803       };
14804     } catch (Dali::DaliException e) {
14805       {
14806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14807       };
14808     } catch (...) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14811       };
14812     }
14813   }
14814
14815 }
14816
14817
14818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14819   Dali::Property *arg1 = (Dali::Property *) 0 ;
14820   Dali::Handle *arg2 = 0 ;
14821
14822   arg1 = (Dali::Property *)jarg1;
14823   arg2 = (Dali::Handle *)jarg2;
14824   if (!arg2) {
14825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14826     return ;
14827   }
14828   if (arg1) (arg1)->object = *arg2;
14829 }
14830
14831
14832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14833   void * jresult ;
14834   Dali::Property *arg1 = (Dali::Property *) 0 ;
14835   Dali::Handle *result = 0 ;
14836
14837   arg1 = (Dali::Property *)jarg1;
14838   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14839   jresult = (void *)result;
14840   return jresult;
14841 }
14842
14843
14844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14845   Dali::Property *arg1 = (Dali::Property *) 0 ;
14846   Dali::Property::Index arg2 ;
14847
14848   arg1 = (Dali::Property *)jarg1;
14849   arg2 = (Dali::Property::Index)jarg2;
14850   if (arg1) (arg1)->propertyIndex = arg2;
14851 }
14852
14853
14854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14855   int jresult ;
14856   Dali::Property *arg1 = (Dali::Property *) 0 ;
14857   Dali::Property::Index result;
14858
14859   arg1 = (Dali::Property *)jarg1;
14860   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14861   jresult = result;
14862   return jresult;
14863 }
14864
14865
14866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14867   Dali::Property *arg1 = (Dali::Property *) 0 ;
14868   int arg2 ;
14869
14870   arg1 = (Dali::Property *)jarg1;
14871   arg2 = (int)jarg2;
14872   if (arg1) (arg1)->componentIndex = arg2;
14873 }
14874
14875
14876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14877   int jresult ;
14878   Dali::Property *arg1 = (Dali::Property *) 0 ;
14879   int result;
14880
14881   arg1 = (Dali::Property *)jarg1;
14882   result = (int) ((arg1)->componentIndex);
14883   jresult = result;
14884   return jresult;
14885 }
14886
14887
14888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14889   void * jresult ;
14890   Dali::Property::Array *result = 0 ;
14891
14892   {
14893     try {
14894       result = (Dali::Property::Array *)new Dali::Property::Array();
14895     } catch (std::out_of_range& e) {
14896       {
14897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14898       };
14899     } catch (std::exception& e) {
14900       {
14901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14902       };
14903     } catch (Dali::DaliException e) {
14904       {
14905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14906       };
14907     } catch (...) {
14908       {
14909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14910       };
14911     }
14912   }
14913
14914   jresult = (void *)result;
14915   return jresult;
14916 }
14917
14918
14919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14920   void * jresult ;
14921   Dali::Property::Array *arg1 = 0 ;
14922   Dali::Property::Array *result = 0 ;
14923
14924   arg1 = (Dali::Property::Array *)jarg1;
14925   if (!arg1) {
14926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14927     return 0;
14928   }
14929   {
14930     try {
14931       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14932     } catch (std::out_of_range& e) {
14933       {
14934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14935       };
14936     } catch (std::exception& e) {
14937       {
14938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14939       };
14940     } catch (Dali::DaliException e) {
14941       {
14942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14943       };
14944     } catch (...) {
14945       {
14946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14947       };
14948     }
14949   }
14950
14951   jresult = (void *)result;
14952   return jresult;
14953 }
14954
14955
14956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14957   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14958
14959   arg1 = (Dali::Property::Array *)jarg1;
14960   {
14961     try {
14962       delete arg1;
14963     } catch (std::out_of_range& e) {
14964       {
14965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14966       };
14967     } catch (std::exception& e) {
14968       {
14969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14970       };
14971     } catch (Dali::DaliException e) {
14972       {
14973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14974       };
14975     } catch (...) {
14976       {
14977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14978       };
14979     }
14980   }
14981
14982 }
14983
14984
14985 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14986   unsigned long jresult ;
14987   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14988   Dali::Property::Array::SizeType result;
14989
14990   arg1 = (Dali::Property::Array *)jarg1;
14991   {
14992     try {
14993       result = ((Dali::Property::Array const *)arg1)->Size();
14994     } catch (std::out_of_range& e) {
14995       {
14996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14997       };
14998     } catch (std::exception& e) {
14999       {
15000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15001       };
15002     } catch (Dali::DaliException e) {
15003       {
15004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15005       };
15006     } catch (...) {
15007       {
15008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15009       };
15010     }
15011   }
15012
15013   jresult = (unsigned long)result;
15014   return jresult;
15015 }
15016
15017
15018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15019   unsigned long jresult ;
15020   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15021   Dali::Property::Array::SizeType result;
15022
15023   arg1 = (Dali::Property::Array *)jarg1;
15024   {
15025     try {
15026       result = ((Dali::Property::Array const *)arg1)->Count();
15027     } catch (std::out_of_range& e) {
15028       {
15029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15030       };
15031     } catch (std::exception& e) {
15032       {
15033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15034       };
15035     } catch (Dali::DaliException e) {
15036       {
15037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15038       };
15039     } catch (...) {
15040       {
15041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15042       };
15043     }
15044   }
15045
15046   jresult = (unsigned long)result;
15047   return jresult;
15048 }
15049
15050
15051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15052   unsigned int jresult ;
15053   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15054   bool result;
15055
15056   arg1 = (Dali::Property::Array *)jarg1;
15057   {
15058     try {
15059       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15060     } catch (std::out_of_range& e) {
15061       {
15062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15063       };
15064     } catch (std::exception& e) {
15065       {
15066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15067       };
15068     } catch (Dali::DaliException e) {
15069       {
15070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15071       };
15072     } catch (...) {
15073       {
15074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15075       };
15076     }
15077   }
15078
15079   jresult = result;
15080   return jresult;
15081 }
15082
15083
15084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15085   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15086
15087   arg1 = (Dali::Property::Array *)jarg1;
15088   {
15089     try {
15090       (arg1)->Clear();
15091     } catch (std::out_of_range& e) {
15092       {
15093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15094       };
15095     } catch (std::exception& e) {
15096       {
15097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15098       };
15099     } catch (Dali::DaliException e) {
15100       {
15101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15102       };
15103     } catch (...) {
15104       {
15105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15106       };
15107     }
15108   }
15109
15110 }
15111
15112
15113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15114   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15115   Dali::Property::Array::SizeType arg2 ;
15116
15117   arg1 = (Dali::Property::Array *)jarg1;
15118   arg2 = (Dali::Property::Array::SizeType)jarg2;
15119   {
15120     try {
15121       (arg1)->Reserve(arg2);
15122     } catch (std::out_of_range& e) {
15123       {
15124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15125       };
15126     } catch (std::exception& e) {
15127       {
15128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15129       };
15130     } catch (Dali::DaliException e) {
15131       {
15132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15133       };
15134     } catch (...) {
15135       {
15136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15137       };
15138     }
15139   }
15140
15141 }
15142
15143
15144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15145   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15146   Dali::Property::Array::SizeType arg2 ;
15147
15148   arg1 = (Dali::Property::Array *)jarg1;
15149   arg2 = (Dali::Property::Array::SizeType)jarg2;
15150   {
15151     try {
15152       (arg1)->Resize(arg2);
15153     } catch (std::out_of_range& e) {
15154       {
15155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15156       };
15157     } catch (std::exception& e) {
15158       {
15159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15160       };
15161     } catch (Dali::DaliException e) {
15162       {
15163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15164       };
15165     } catch (...) {
15166       {
15167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15168       };
15169     }
15170   }
15171
15172 }
15173
15174
15175 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15176   unsigned long jresult ;
15177   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15178   Dali::Property::Array::SizeType result;
15179
15180   arg1 = (Dali::Property::Array *)jarg1;
15181   {
15182     try {
15183       result = (arg1)->Capacity();
15184     } catch (std::out_of_range& e) {
15185       {
15186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15187       };
15188     } catch (std::exception& e) {
15189       {
15190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15191       };
15192     } catch (Dali::DaliException e) {
15193       {
15194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15195       };
15196     } catch (...) {
15197       {
15198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15199       };
15200     }
15201   }
15202
15203   jresult = (unsigned long)result;
15204   return jresult;
15205 }
15206
15207
15208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15209   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15210   Dali::Property::Value *arg2 = 0 ;
15211
15212   arg1 = (Dali::Property::Array *)jarg1;
15213   arg2 = (Dali::Property::Value *)jarg2;
15214   if (!arg2) {
15215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15216     return ;
15217   }
15218   {
15219     try {
15220       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15221     } catch (std::out_of_range& e) {
15222       {
15223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15224       };
15225     } catch (std::exception& e) {
15226       {
15227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15228       };
15229     } catch (Dali::DaliException e) {
15230       {
15231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15232       };
15233     } catch (...) {
15234       {
15235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15236       };
15237     }
15238   }
15239
15240 }
15241
15242
15243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15244   void * jresult ;
15245   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15246   Dali::Property::Value *arg2 = 0 ;
15247   Dali::Property::Array *result = 0 ;
15248
15249   arg1 = (Dali::Property::Array *)jarg1;
15250   arg2 = (Dali::Property::Value *)jarg2;
15251   if (!arg2) {
15252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15253     return 0;
15254   }
15255   {
15256     try {
15257       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15258     } catch (std::out_of_range& e) {
15259       {
15260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15261       };
15262     } catch (std::exception& e) {
15263       {
15264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15265       };
15266     } catch (Dali::DaliException e) {
15267       {
15268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15269       };
15270     } catch (...) {
15271       {
15272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15273       };
15274     }
15275   }
15276
15277   jresult = (void *)result;
15278   return jresult;
15279 }
15280
15281
15282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15283   void * jresult ;
15284   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15285   Dali::Property::Array::SizeType arg2 ;
15286   Dali::Property::Value *result = 0 ;
15287
15288   arg1 = (Dali::Property::Array *)jarg1;
15289   arg2 = (Dali::Property::Array::SizeType)jarg2;
15290   {
15291     try {
15292       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15293     } catch (std::out_of_range& e) {
15294       {
15295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15296       };
15297     } catch (std::exception& e) {
15298       {
15299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (Dali::DaliException e) {
15302       {
15303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15304       };
15305     } catch (...) {
15306       {
15307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15308       };
15309     }
15310   }
15311
15312   jresult = (void *)result;
15313   return jresult;
15314 }
15315
15316
15317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15318   void * jresult ;
15319   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15320   Dali::Property::Array::SizeType arg2 ;
15321   Dali::Property::Value *result = 0 ;
15322
15323   arg1 = (Dali::Property::Array *)jarg1;
15324   arg2 = (Dali::Property::Array::SizeType)jarg2;
15325   {
15326     try {
15327       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15328     } catch (std::out_of_range& e) {
15329       {
15330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (std::exception& e) {
15333       {
15334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15335       };
15336     } catch (Dali::DaliException e) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15339       };
15340     } catch (...) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15343       };
15344     }
15345   }
15346
15347   jresult = (void *)result;
15348   return jresult;
15349 }
15350
15351
15352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15353   void * jresult ;
15354   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15355   Dali::Property::Array *arg2 = 0 ;
15356   Dali::Property::Array *result = 0 ;
15357
15358   arg1 = (Dali::Property::Array *)jarg1;
15359   arg2 = (Dali::Property::Array *)jarg2;
15360   if (!arg2) {
15361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15362     return 0;
15363   }
15364   {
15365     try {
15366       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15367     } catch (std::out_of_range& e) {
15368       {
15369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15370       };
15371     } catch (std::exception& e) {
15372       {
15373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15374       };
15375     } catch (Dali::DaliException e) {
15376       {
15377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15378       };
15379     } catch (...) {
15380       {
15381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15382       };
15383     }
15384   }
15385
15386   jresult = (void *)result;
15387   return jresult;
15388 }
15389
15390
15391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15392   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15393   enum Dali::Property::Key::Type arg2 ;
15394
15395   arg1 = (Dali::Property::Key *)jarg1;
15396   arg2 = (enum Dali::Property::Key::Type)jarg2;
15397   if (arg1) (arg1)->type = arg2;
15398 }
15399
15400
15401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15402   int jresult ;
15403   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15404   enum Dali::Property::Key::Type result;
15405
15406   arg1 = (Dali::Property::Key *)jarg1;
15407   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15408   jresult = (int)result;
15409   return jresult;
15410 }
15411
15412
15413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15414   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15415   Dali::Property::Index arg2 ;
15416
15417   arg1 = (Dali::Property::Key *)jarg1;
15418   arg2 = (Dali::Property::Index)jarg2;
15419   if (arg1) (arg1)->indexKey = arg2;
15420 }
15421
15422
15423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15424   int jresult ;
15425   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15426   Dali::Property::Index result;
15427
15428   arg1 = (Dali::Property::Key *)jarg1;
15429   result = (Dali::Property::Index) ((arg1)->indexKey);
15430   jresult = result;
15431   return jresult;
15432 }
15433
15434
15435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15436   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15437   std::string *arg2 = 0 ;
15438
15439   arg1 = (Dali::Property::Key *)jarg1;
15440   if (!jarg2) {
15441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15442     return ;
15443   }
15444   std::string arg2_str(jarg2);
15445   arg2 = &arg2_str;
15446   if (arg1) (arg1)->stringKey = *arg2;
15447
15448   //argout typemap for const std::string&
15449
15450 }
15451
15452
15453 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15454   char * jresult ;
15455   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15456   std::string *result = 0 ;
15457
15458   arg1 = (Dali::Property::Key *)jarg1;
15459   result = (std::string *) & ((arg1)->stringKey);
15460   jresult = SWIG_csharp_string_callback(result->c_str());
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15466   void * jresult ;
15467   std::string *arg1 = 0 ;
15468   Dali::Property::Key *result = 0 ;
15469
15470   if (!jarg1) {
15471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15472     return 0;
15473   }
15474   std::string arg1_str(jarg1);
15475   arg1 = &arg1_str;
15476   {
15477     try {
15478       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15479     } catch (std::out_of_range& e) {
15480       {
15481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15482       };
15483     } catch (std::exception& e) {
15484       {
15485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15486       };
15487     } catch (Dali::DaliException e) {
15488       {
15489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15490       };
15491     } catch (...) {
15492       {
15493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15494       };
15495     }
15496   }
15497
15498   jresult = (void *)result;
15499
15500   //argout typemap for const std::string&
15501
15502   return jresult;
15503 }
15504
15505
15506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15507   void * jresult ;
15508   Dali::Property::Index arg1 ;
15509   Dali::Property::Key *result = 0 ;
15510
15511   arg1 = (Dali::Property::Index)jarg1;
15512   {
15513     try {
15514       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15515     } catch (std::out_of_range& e) {
15516       {
15517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15518       };
15519     } catch (std::exception& e) {
15520       {
15521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15522       };
15523     } catch (Dali::DaliException e) {
15524       {
15525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15526       };
15527     } catch (...) {
15528       {
15529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15530       };
15531     }
15532   }
15533
15534   jresult = (void *)result;
15535   return jresult;
15536 }
15537
15538
15539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15540   unsigned int jresult ;
15541   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15542   std::string *arg2 = 0 ;
15543   bool result;
15544
15545   arg1 = (Dali::Property::Key *)jarg1;
15546   if (!jarg2) {
15547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15548     return 0;
15549   }
15550   std::string arg2_str(jarg2);
15551   arg2 = &arg2_str;
15552   {
15553     try {
15554       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15555     } catch (std::out_of_range& e) {
15556       {
15557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15558       };
15559     } catch (std::exception& e) {
15560       {
15561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15562       };
15563     } catch (Dali::DaliException e) {
15564       {
15565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15566       };
15567     } catch (...) {
15568       {
15569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15570       };
15571     }
15572   }
15573
15574   jresult = result;
15575
15576   //argout typemap for const std::string&
15577
15578   return jresult;
15579 }
15580
15581
15582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15583   unsigned int jresult ;
15584   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15585   Dali::Property::Index arg2 ;
15586   bool result;
15587
15588   arg1 = (Dali::Property::Key *)jarg1;
15589   arg2 = (Dali::Property::Index)jarg2;
15590   {
15591     try {
15592       result = (bool)(arg1)->operator ==(arg2);
15593     } catch (std::out_of_range& e) {
15594       {
15595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (std::exception& e) {
15598       {
15599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15600       };
15601     } catch (Dali::DaliException e) {
15602       {
15603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15604       };
15605     } catch (...) {
15606       {
15607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15608       };
15609     }
15610   }
15611
15612   jresult = result;
15613   return jresult;
15614 }
15615
15616
15617 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15618   unsigned int jresult ;
15619   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15620   Dali::Property::Key *arg2 = 0 ;
15621   bool result;
15622
15623   arg1 = (Dali::Property::Key *)jarg1;
15624   arg2 = (Dali::Property::Key *)jarg2;
15625   if (!arg2) {
15626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15627     return 0;
15628   }
15629   {
15630     try {
15631       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15632     } catch (std::out_of_range& e) {
15633       {
15634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15635       };
15636     } catch (std::exception& e) {
15637       {
15638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15639       };
15640     } catch (Dali::DaliException e) {
15641       {
15642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15643       };
15644     } catch (...) {
15645       {
15646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15647       };
15648     }
15649   }
15650
15651   jresult = result;
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15657   unsigned int jresult ;
15658   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15659   std::string *arg2 = 0 ;
15660   bool result;
15661
15662   arg1 = (Dali::Property::Key *)jarg1;
15663   if (!jarg2) {
15664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15665     return 0;
15666   }
15667   std::string arg2_str(jarg2);
15668   arg2 = &arg2_str;
15669   {
15670     try {
15671       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15672     } catch (std::out_of_range& e) {
15673       {
15674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15675       };
15676     } catch (std::exception& e) {
15677       {
15678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (Dali::DaliException e) {
15681       {
15682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15683       };
15684     } catch (...) {
15685       {
15686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15687       };
15688     }
15689   }
15690
15691   jresult = result;
15692
15693   //argout typemap for const std::string&
15694
15695   return jresult;
15696 }
15697
15698
15699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15700   unsigned int jresult ;
15701   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15702   Dali::Property::Index arg2 ;
15703   bool result;
15704
15705   arg1 = (Dali::Property::Key *)jarg1;
15706   arg2 = (Dali::Property::Index)jarg2;
15707   {
15708     try {
15709       result = (bool)(arg1)->operator !=(arg2);
15710     } catch (std::out_of_range& e) {
15711       {
15712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (std::exception& e) {
15715       {
15716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (Dali::DaliException e) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15721       };
15722     } catch (...) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15725       };
15726     }
15727   }
15728
15729   jresult = result;
15730   return jresult;
15731 }
15732
15733
15734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15735   unsigned int jresult ;
15736   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15737   Dali::Property::Key *arg2 = 0 ;
15738   bool result;
15739
15740   arg1 = (Dali::Property::Key *)jarg1;
15741   arg2 = (Dali::Property::Key *)jarg2;
15742   if (!arg2) {
15743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15744     return 0;
15745   }
15746   {
15747     try {
15748       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15749     } catch (std::out_of_range& e) {
15750       {
15751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15752       };
15753     } catch (std::exception& e) {
15754       {
15755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15756       };
15757     } catch (Dali::DaliException e) {
15758       {
15759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15760       };
15761     } catch (...) {
15762       {
15763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15764       };
15765     }
15766   }
15767
15768   jresult = result;
15769   return jresult;
15770 }
15771
15772
15773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15774   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15775
15776   arg1 = (Dali::Property::Key *)jarg1;
15777   {
15778     try {
15779       delete arg1;
15780     } catch (std::out_of_range& e) {
15781       {
15782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15783       };
15784     } catch (std::exception& e) {
15785       {
15786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15787       };
15788     } catch (Dali::DaliException e) {
15789       {
15790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15791       };
15792     } catch (...) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15795       };
15796     }
15797   }
15798
15799 }
15800
15801
15802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15803   void * jresult ;
15804   Dali::Property::Map *result = 0 ;
15805
15806   {
15807     try {
15808       result = (Dali::Property::Map *)new Dali::Property::Map();
15809     } catch (std::out_of_range& e) {
15810       {
15811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (std::exception& e) {
15814       {
15815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (Dali::DaliException e) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15820       };
15821     } catch (...) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15824       };
15825     }
15826   }
15827
15828   jresult = (void *)result;
15829   return jresult;
15830 }
15831
15832
15833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15834   void * jresult ;
15835   Dali::Property::Map *arg1 = 0 ;
15836   Dali::Property::Map *result = 0 ;
15837
15838   arg1 = (Dali::Property::Map *)jarg1;
15839   if (!arg1) {
15840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15841     return 0;
15842   }
15843   {
15844     try {
15845       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15846     } catch (std::out_of_range& e) {
15847       {
15848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15849       };
15850     } catch (std::exception& e) {
15851       {
15852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (Dali::DaliException e) {
15855       {
15856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15857       };
15858     } catch (...) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15861       };
15862     }
15863   }
15864
15865   jresult = (void *)result;
15866   return jresult;
15867 }
15868
15869
15870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15871   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15872
15873   arg1 = (Dali::Property::Map *)jarg1;
15874   {
15875     try {
15876       delete arg1;
15877     } catch (std::out_of_range& e) {
15878       {
15879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15880       };
15881     } catch (std::exception& e) {
15882       {
15883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15884       };
15885     } catch (Dali::DaliException e) {
15886       {
15887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15888       };
15889     } catch (...) {
15890       {
15891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15892       };
15893     }
15894   }
15895
15896 }
15897
15898
15899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15900   unsigned long jresult ;
15901   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15902   Dali::Property::Map::SizeType result;
15903
15904   arg1 = (Dali::Property::Map *)jarg1;
15905   {
15906     try {
15907       result = ((Dali::Property::Map const *)arg1)->Count();
15908     } catch (std::out_of_range& e) {
15909       {
15910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15911       };
15912     } catch (std::exception& e) {
15913       {
15914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (Dali::DaliException e) {
15917       {
15918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15919       };
15920     } catch (...) {
15921       {
15922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15923       };
15924     }
15925   }
15926
15927   jresult = (unsigned long)result;
15928   return jresult;
15929 }
15930
15931
15932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15933   unsigned int jresult ;
15934   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15935   bool result;
15936
15937   arg1 = (Dali::Property::Map *)jarg1;
15938   {
15939     try {
15940       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15941     } catch (std::out_of_range& e) {
15942       {
15943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15944       };
15945     } catch (std::exception& e) {
15946       {
15947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15948       };
15949     } catch (Dali::DaliException e) {
15950       {
15951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15952       };
15953     } catch (...) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15956       };
15957     }
15958   }
15959
15960   jresult = result;
15961   return jresult;
15962 }
15963
15964
15965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15966   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15967   char *arg2 = (char *) 0 ;
15968   Dali::Property::Value *arg3 = 0 ;
15969
15970   arg1 = (Dali::Property::Map *)jarg1;
15971   arg2 = (char *)jarg2;
15972   arg3 = (Dali::Property::Value *)jarg3;
15973   if (!arg3) {
15974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15975     return ;
15976   }
15977   {
15978     try {
15979       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15980     } catch (std::out_of_range& e) {
15981       {
15982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15983       };
15984     } catch (std::exception& e) {
15985       {
15986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15987       };
15988     } catch (Dali::DaliException e) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15991       };
15992     } catch (...) {
15993       {
15994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15995       };
15996     }
15997   }
15998
15999 }
16000
16001
16002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16003   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16004   Dali::Property::Index arg2 ;
16005   Dali::Property::Value *arg3 = 0 ;
16006
16007   arg1 = (Dali::Property::Map *)jarg1;
16008   arg2 = (Dali::Property::Index)jarg2;
16009   arg3 = (Dali::Property::Value *)jarg3;
16010   if (!arg3) {
16011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16012     return ;
16013   }
16014   {
16015     try {
16016       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16017     } catch (std::out_of_range& e) {
16018       {
16019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16020       };
16021     } catch (std::exception& e) {
16022       {
16023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16024       };
16025     } catch (Dali::DaliException e) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16028       };
16029     } catch (...) {
16030       {
16031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16032       };
16033     }
16034   }
16035
16036 }
16037
16038
16039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16040   void * jresult ;
16041   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16042   char *arg2 = (char *) 0 ;
16043   Dali::Property::Value *arg3 = 0 ;
16044   Dali::Property::Map *result = 0 ;
16045
16046   arg1 = (Dali::Property::Map *)jarg1;
16047   arg2 = (char *)jarg2;
16048   arg3 = (Dali::Property::Value *)jarg3;
16049   if (!arg3) {
16050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16051     return 0;
16052   }
16053   {
16054     try {
16055       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (Dali::DaliException e) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16067       };
16068     } catch (...) {
16069       {
16070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16071       };
16072     }
16073   }
16074
16075   jresult = (void *)result;
16076   return jresult;
16077 }
16078
16079
16080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16081   void * jresult ;
16082   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16083   Dali::Property::Index arg2 ;
16084   Dali::Property::Value *arg3 = 0 ;
16085   Dali::Property::Map *result = 0 ;
16086
16087   arg1 = (Dali::Property::Map *)jarg1;
16088   arg2 = (Dali::Property::Index)jarg2;
16089   arg3 = (Dali::Property::Value *)jarg3;
16090   if (!arg3) {
16091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16092     return 0;
16093   }
16094   {
16095     try {
16096       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16097     } catch (std::out_of_range& e) {
16098       {
16099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16100       };
16101     } catch (std::exception& e) {
16102       {
16103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16104       };
16105     } catch (Dali::DaliException e) {
16106       {
16107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16108       };
16109     } catch (...) {
16110       {
16111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16112       };
16113     }
16114   }
16115
16116   jresult = (void *)result;
16117   return jresult;
16118 }
16119
16120
16121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16122   void * jresult ;
16123   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16124   Dali::Property::Map::SizeType arg2 ;
16125   Dali::Property::Value *result = 0 ;
16126
16127   arg1 = (Dali::Property::Map *)jarg1;
16128   arg2 = (Dali::Property::Map::SizeType)jarg2;
16129   {
16130     try {
16131       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16132     } catch (std::out_of_range& e) {
16133       {
16134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16135       };
16136     } catch (std::exception& e) {
16137       {
16138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16139       };
16140     } catch (Dali::DaliException e) {
16141       {
16142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16143       };
16144     } catch (...) {
16145       {
16146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16147       };
16148     }
16149   }
16150
16151   jresult = (void *)result;
16152   return jresult;
16153 }
16154
16155
16156 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16157   char * jresult ;
16158   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16159   Dali::Property::Map::SizeType arg2 ;
16160   std::string *result = 0 ;
16161
16162   arg1 = (Dali::Property::Map *)jarg1;
16163   arg2 = (Dali::Property::Map::SizeType)jarg2;
16164   {
16165     try {
16166       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16167     } catch (std::out_of_range& e) {
16168       {
16169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16170       };
16171     } catch (std::exception& e) {
16172       {
16173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16174       };
16175     } catch (Dali::DaliException e) {
16176       {
16177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16178       };
16179     } catch (...) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16182       };
16183     }
16184   }
16185
16186   jresult = SWIG_csharp_string_callback(result->c_str());
16187   return jresult;
16188 }
16189
16190
16191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16192   void * jresult ;
16193   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16194   Dali::Property::Map::SizeType arg2 ;
16195   SwigValueWrapper< Dali::Property::Key > result;
16196
16197   arg1 = (Dali::Property::Map *)jarg1;
16198   arg2 = (Dali::Property::Map::SizeType)jarg2;
16199   {
16200     try {
16201       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16202     } catch (std::out_of_range& e) {
16203       {
16204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16205       };
16206     } catch (std::exception& e) {
16207       {
16208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16209       };
16210     } catch (Dali::DaliException e) {
16211       {
16212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16213       };
16214     } catch (...) {
16215       {
16216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16217       };
16218     }
16219   }
16220
16221   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16222   return jresult;
16223 }
16224
16225
16226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16227   void * jresult ;
16228   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16229   Dali::Property::Map::SizeType arg2 ;
16230   StringValuePair *result = 0 ;
16231
16232   arg1 = (Dali::Property::Map *)jarg1;
16233   arg2 = (Dali::Property::Map::SizeType)jarg2;
16234   {
16235     try {
16236       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16237     } catch (std::out_of_range& e) {
16238       {
16239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16240       };
16241     } catch (std::exception& e) {
16242       {
16243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16244       };
16245     } catch (Dali::DaliException e) {
16246       {
16247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16248       };
16249     } catch (...) {
16250       {
16251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16252       };
16253     }
16254   }
16255
16256   jresult = (void *)result;
16257   return jresult;
16258 }
16259
16260
16261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16262   void * jresult ;
16263   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16264   char *arg2 = (char *) 0 ;
16265   Dali::Property::Value *result = 0 ;
16266
16267   arg1 = (Dali::Property::Map *)jarg1;
16268   arg2 = (char *)jarg2;
16269   {
16270     try {
16271       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16272     } catch (std::out_of_range& e) {
16273       {
16274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16275       };
16276     } catch (std::exception& e) {
16277       {
16278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (Dali::DaliException e) {
16281       {
16282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16283       };
16284     } catch (...) {
16285       {
16286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16287       };
16288     }
16289   }
16290
16291   jresult = (void *)result;
16292   return jresult;
16293 }
16294
16295
16296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16297   void * jresult ;
16298   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16299   Dali::Property::Index arg2 ;
16300   Dali::Property::Value *result = 0 ;
16301
16302   arg1 = (Dali::Property::Map *)jarg1;
16303   arg2 = (Dali::Property::Index)jarg2;
16304   {
16305     try {
16306       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16307     } catch (std::out_of_range& e) {
16308       {
16309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16310       };
16311     } catch (std::exception& e) {
16312       {
16313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (Dali::DaliException e) {
16316       {
16317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16318       };
16319     } catch (...) {
16320       {
16321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16322       };
16323     }
16324   }
16325
16326   jresult = (void *)result;
16327   return jresult;
16328 }
16329
16330
16331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16332   void * jresult ;
16333   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16334   Dali::Property::Index arg2 ;
16335   std::string *arg3 = 0 ;
16336   Dali::Property::Value *result = 0 ;
16337
16338   arg1 = (Dali::Property::Map *)jarg1;
16339   arg2 = (Dali::Property::Index)jarg2;
16340   if (!jarg3) {
16341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16342     return 0;
16343   }
16344   std::string arg3_str(jarg3);
16345   arg3 = &arg3_str;
16346   {
16347     try {
16348       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16349     } catch (std::out_of_range& e) {
16350       {
16351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16352       };
16353     } catch (std::exception& e) {
16354       {
16355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16356       };
16357     } catch (Dali::DaliException e) {
16358       {
16359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16360       };
16361     } catch (...) {
16362       {
16363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16364       };
16365     }
16366   }
16367
16368   jresult = (void *)result;
16369
16370   //argout typemap for const std::string&
16371
16372   return jresult;
16373 }
16374
16375
16376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16377   void * jresult ;
16378   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16379   std::string *arg2 = 0 ;
16380   Dali::Property::Type arg3 ;
16381   Dali::Property::Value *result = 0 ;
16382
16383   arg1 = (Dali::Property::Map *)jarg1;
16384   if (!jarg2) {
16385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16386     return 0;
16387   }
16388   std::string arg2_str(jarg2);
16389   arg2 = &arg2_str;
16390   arg3 = (Dali::Property::Type)jarg3;
16391   {
16392     try {
16393       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16394     } catch (std::out_of_range& e) {
16395       {
16396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16397       };
16398     } catch (std::exception& e) {
16399       {
16400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (Dali::DaliException e) {
16403       {
16404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16405       };
16406     } catch (...) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16409       };
16410     }
16411   }
16412
16413   jresult = (void *)result;
16414
16415   //argout typemap for const std::string&
16416
16417   return jresult;
16418 }
16419
16420
16421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16422   void * jresult ;
16423   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16424   Dali::Property::Index arg2 ;
16425   Dali::Property::Type arg3 ;
16426   Dali::Property::Value *result = 0 ;
16427
16428   arg1 = (Dali::Property::Map *)jarg1;
16429   arg2 = (Dali::Property::Index)jarg2;
16430   arg3 = (Dali::Property::Type)jarg3;
16431   {
16432     try {
16433       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16434     } catch (std::out_of_range& e) {
16435       {
16436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16437       };
16438     } catch (std::exception& e) {
16439       {
16440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16441       };
16442     } catch (Dali::DaliException e) {
16443       {
16444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16445       };
16446     } catch (...) {
16447       {
16448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16449       };
16450     }
16451   }
16452
16453   jresult = (void *)result;
16454   return jresult;
16455 }
16456
16457
16458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16459   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16460
16461   arg1 = (Dali::Property::Map *)jarg1;
16462   {
16463     try {
16464       (arg1)->Clear();
16465     } catch (std::out_of_range& e) {
16466       {
16467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16468       };
16469     } catch (std::exception& e) {
16470       {
16471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16472       };
16473     } catch (Dali::DaliException e) {
16474       {
16475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16476       };
16477     } catch (...) {
16478       {
16479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16480       };
16481     }
16482   }
16483
16484 }
16485
16486
16487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16488   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16489   Dali::Property::Map *arg2 = 0 ;
16490
16491   arg1 = (Dali::Property::Map *)jarg1;
16492   arg2 = (Dali::Property::Map *)jarg2;
16493   if (!arg2) {
16494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16495     return ;
16496   }
16497   {
16498     try {
16499       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16500     } catch (std::out_of_range& e) {
16501       {
16502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16503       };
16504     } catch (std::exception& e) {
16505       {
16506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16507       };
16508     } catch (Dali::DaliException e) {
16509       {
16510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16511       };
16512     } catch (...) {
16513       {
16514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16515       };
16516     }
16517   }
16518
16519 }
16520
16521
16522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16523   void * jresult ;
16524   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16525   std::string *arg2 = 0 ;
16526   Dali::Property::Value *result = 0 ;
16527
16528   arg1 = (Dali::Property::Map *)jarg1;
16529   if (!jarg2) {
16530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16531     return 0;
16532   }
16533   std::string arg2_str(jarg2);
16534   arg2 = &arg2_str;
16535   {
16536     try {
16537       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16538     } catch (std::out_of_range& e) {
16539       {
16540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16541       };
16542     } catch (std::exception& e) {
16543       {
16544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16545       };
16546     } catch (Dali::DaliException e) {
16547       {
16548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16549       };
16550     } catch (...) {
16551       {
16552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16553       };
16554     }
16555   }
16556
16557   jresult = (void *)result;
16558
16559   //argout typemap for const std::string&
16560
16561   return jresult;
16562 }
16563
16564
16565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16566   void * jresult ;
16567   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16568   Dali::Property::Index arg2 ;
16569   Dali::Property::Value *result = 0 ;
16570
16571   arg1 = (Dali::Property::Map *)jarg1;
16572   arg2 = (Dali::Property::Index)jarg2;
16573   {
16574     try {
16575       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16576     } catch (std::out_of_range& e) {
16577       {
16578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (std::exception& e) {
16581       {
16582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (Dali::DaliException e) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16587       };
16588     } catch (...) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16591       };
16592     }
16593   }
16594
16595   jresult = (void *)result;
16596   return jresult;
16597 }
16598
16599
16600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16601   void * jresult ;
16602   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16603   Dali::Property::Map *arg2 = 0 ;
16604   Dali::Property::Map *result = 0 ;
16605
16606   arg1 = (Dali::Property::Map *)jarg1;
16607   arg2 = (Dali::Property::Map *)jarg2;
16608   if (!arg2) {
16609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16610     return 0;
16611   }
16612   {
16613     try {
16614       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16615     } catch (std::out_of_range& e) {
16616       {
16617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16618       };
16619     } catch (std::exception& e) {
16620       {
16621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16622       };
16623     } catch (Dali::DaliException e) {
16624       {
16625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16626       };
16627     } catch (...) {
16628       {
16629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16630       };
16631     }
16632   }
16633
16634   jresult = (void *)result;
16635   return jresult;
16636 }
16637
16638
16639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16640   void * jresult ;
16641   Dali::Property::Value *result = 0 ;
16642
16643   {
16644     try {
16645       result = (Dali::Property::Value *)new Dali::Property::Value();
16646     } catch (std::out_of_range& e) {
16647       {
16648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16649       };
16650     } catch (std::exception& e) {
16651       {
16652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16653       };
16654     } catch (Dali::DaliException e) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16657       };
16658     } catch (...) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16661       };
16662     }
16663   }
16664
16665   jresult = (void *)result;
16666   return jresult;
16667 }
16668
16669
16670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16671   void * jresult ;
16672   bool arg1 ;
16673   Dali::Property::Value *result = 0 ;
16674
16675   arg1 = jarg1 ? true : false;
16676   {
16677     try {
16678       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16679     } catch (std::out_of_range& e) {
16680       {
16681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16682       };
16683     } catch (std::exception& e) {
16684       {
16685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16686       };
16687     } catch (Dali::DaliException e) {
16688       {
16689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16690       };
16691     } catch (...) {
16692       {
16693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16694       };
16695     }
16696   }
16697
16698   jresult = (void *)result;
16699   return jresult;
16700 }
16701
16702
16703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16704   void * jresult ;
16705   int arg1 ;
16706   Dali::Property::Value *result = 0 ;
16707
16708   arg1 = (int)jarg1;
16709   {
16710     try {
16711       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16712     } catch (std::out_of_range& e) {
16713       {
16714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16715       };
16716     } catch (std::exception& e) {
16717       {
16718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16719       };
16720     } catch (Dali::DaliException e) {
16721       {
16722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16723       };
16724     } catch (...) {
16725       {
16726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16727       };
16728     }
16729   }
16730
16731   jresult = (void *)result;
16732   return jresult;
16733 }
16734
16735
16736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16737   void * jresult ;
16738   float arg1 ;
16739   Dali::Property::Value *result = 0 ;
16740
16741   arg1 = (float)jarg1;
16742   {
16743     try {
16744       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16745     } catch (std::out_of_range& e) {
16746       {
16747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16748       };
16749     } catch (std::exception& e) {
16750       {
16751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16752       };
16753     } catch (Dali::DaliException e) {
16754       {
16755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16756       };
16757     } catch (...) {
16758       {
16759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16760       };
16761     }
16762   }
16763
16764   jresult = (void *)result;
16765   return jresult;
16766 }
16767
16768
16769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16770   void * jresult ;
16771   Dali::Vector2 *arg1 = 0 ;
16772   Dali::Property::Value *result = 0 ;
16773
16774   arg1 = (Dali::Vector2 *)jarg1;
16775   if (!arg1) {
16776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16777     return 0;
16778   }
16779   {
16780     try {
16781       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16782     } catch (std::out_of_range& e) {
16783       {
16784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16785       };
16786     } catch (std::exception& e) {
16787       {
16788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16789       };
16790     } catch (Dali::DaliException e) {
16791       {
16792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16793       };
16794     } catch (...) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16797       };
16798     }
16799   }
16800
16801   jresult = (void *)result;
16802   return jresult;
16803 }
16804
16805
16806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16807   void * jresult ;
16808   Dali::Vector3 *arg1 = 0 ;
16809   Dali::Property::Value *result = 0 ;
16810
16811   arg1 = (Dali::Vector3 *)jarg1;
16812   if (!arg1) {
16813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16814     return 0;
16815   }
16816   {
16817     try {
16818       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16819     } catch (std::out_of_range& e) {
16820       {
16821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16822       };
16823     } catch (std::exception& e) {
16824       {
16825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16826       };
16827     } catch (Dali::DaliException e) {
16828       {
16829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16830       };
16831     } catch (...) {
16832       {
16833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16834       };
16835     }
16836   }
16837
16838   jresult = (void *)result;
16839   return jresult;
16840 }
16841
16842
16843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16844   void * jresult ;
16845   Dali::Vector4 *arg1 = 0 ;
16846   Dali::Property::Value *result = 0 ;
16847
16848   arg1 = (Dali::Vector4 *)jarg1;
16849   if (!arg1) {
16850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16851     return 0;
16852   }
16853   {
16854     try {
16855       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16856     } catch (std::out_of_range& e) {
16857       {
16858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16859       };
16860     } catch (std::exception& e) {
16861       {
16862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16863       };
16864     } catch (Dali::DaliException e) {
16865       {
16866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16867       };
16868     } catch (...) {
16869       {
16870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16871       };
16872     }
16873   }
16874
16875   jresult = (void *)result;
16876   return jresult;
16877 }
16878
16879
16880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16881   void * jresult ;
16882   Dali::Matrix3 *arg1 = 0 ;
16883   Dali::Property::Value *result = 0 ;
16884
16885   arg1 = (Dali::Matrix3 *)jarg1;
16886   if (!arg1) {
16887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16888     return 0;
16889   }
16890   {
16891     try {
16892       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16893     } catch (std::out_of_range& e) {
16894       {
16895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16896       };
16897     } catch (std::exception& e) {
16898       {
16899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (Dali::DaliException e) {
16902       {
16903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16904       };
16905     } catch (...) {
16906       {
16907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16908       };
16909     }
16910   }
16911
16912   jresult = (void *)result;
16913   return jresult;
16914 }
16915
16916
16917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16918   void * jresult ;
16919   Dali::Matrix *arg1 = 0 ;
16920   Dali::Property::Value *result = 0 ;
16921
16922   arg1 = (Dali::Matrix *)jarg1;
16923   if (!arg1) {
16924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16925     return 0;
16926   }
16927   {
16928     try {
16929       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16930     } catch (std::out_of_range& e) {
16931       {
16932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16933       };
16934     } catch (std::exception& e) {
16935       {
16936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16937       };
16938     } catch (Dali::DaliException e) {
16939       {
16940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16941       };
16942     } catch (...) {
16943       {
16944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16945       };
16946     }
16947   }
16948
16949   jresult = (void *)result;
16950   return jresult;
16951 }
16952
16953
16954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16955   void * jresult ;
16956   Dali::Rect< int > *arg1 = 0 ;
16957   Dali::Property::Value *result = 0 ;
16958
16959   arg1 = (Dali::Rect< int > *)jarg1;
16960   if (!arg1) {
16961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16962     return 0;
16963   }
16964   {
16965     try {
16966       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16967     } catch (std::out_of_range& e) {
16968       {
16969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16970       };
16971     } catch (std::exception& e) {
16972       {
16973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (Dali::DaliException e) {
16976       {
16977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16978       };
16979     } catch (...) {
16980       {
16981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16982       };
16983     }
16984   }
16985
16986   jresult = (void *)result;
16987   return jresult;
16988 }
16989
16990
16991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16992   void * jresult ;
16993   Dali::AngleAxis *arg1 = 0 ;
16994   Dali::Property::Value *result = 0 ;
16995
16996   arg1 = (Dali::AngleAxis *)jarg1;
16997   if (!arg1) {
16998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
16999     return 0;
17000   }
17001   {
17002     try {
17003       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17004     } catch (std::out_of_range& e) {
17005       {
17006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17007       };
17008     } catch (std::exception& e) {
17009       {
17010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17011       };
17012     } catch (Dali::DaliException e) {
17013       {
17014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17015       };
17016     } catch (...) {
17017       {
17018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17019       };
17020     }
17021   }
17022
17023   jresult = (void *)result;
17024   return jresult;
17025 }
17026
17027
17028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17029   void * jresult ;
17030   Dali::Quaternion *arg1 = 0 ;
17031   Dali::Property::Value *result = 0 ;
17032
17033   arg1 = (Dali::Quaternion *)jarg1;
17034   if (!arg1) {
17035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17036     return 0;
17037   }
17038   {
17039     try {
17040       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17041     } catch (std::out_of_range& e) {
17042       {
17043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17044       };
17045     } catch (std::exception& e) {
17046       {
17047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17048       };
17049     } catch (Dali::DaliException e) {
17050       {
17051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17052       };
17053     } catch (...) {
17054       {
17055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17056       };
17057     }
17058   }
17059
17060   jresult = (void *)result;
17061   return jresult;
17062 }
17063
17064
17065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17066   void * jresult ;
17067   std::string *arg1 = 0 ;
17068   Dali::Property::Value *result = 0 ;
17069
17070   if (!jarg1) {
17071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17072     return 0;
17073   }
17074   std::string arg1_str(jarg1);
17075   arg1 = &arg1_str;
17076   {
17077     try {
17078       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17079     } catch (std::out_of_range& e) {
17080       {
17081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17082       };
17083     } catch (std::exception& e) {
17084       {
17085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (Dali::DaliException e) {
17088       {
17089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17090       };
17091     } catch (...) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17094       };
17095     }
17096   }
17097
17098   jresult = (void *)result;
17099
17100   //argout typemap for const std::string&
17101
17102   return jresult;
17103 }
17104
17105
17106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17107   void * jresult ;
17108   Dali::Property::Array *arg1 = 0 ;
17109   Dali::Property::Value *result = 0 ;
17110
17111   arg1 = (Dali::Property::Array *)jarg1;
17112   if (!arg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17114     return 0;
17115   }
17116   {
17117     try {
17118       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (Dali::DaliException e) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17130       };
17131     } catch (...) {
17132       {
17133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17134       };
17135     }
17136   }
17137
17138   jresult = (void *)result;
17139   return jresult;
17140 }
17141
17142
17143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17144   void * jresult ;
17145   Dali::Property::Map *arg1 = 0 ;
17146   Dali::Property::Value *result = 0 ;
17147
17148   arg1 = (Dali::Property::Map *)jarg1;
17149   if (!arg1) {
17150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17151     return 0;
17152   }
17153   {
17154     try {
17155       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17156     } catch (std::out_of_range& e) {
17157       {
17158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17159       };
17160     } catch (std::exception& e) {
17161       {
17162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (Dali::DaliException e) {
17165       {
17166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17167       };
17168     } catch (...) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17171       };
17172     }
17173   }
17174
17175   jresult = (void *)result;
17176   return jresult;
17177 }
17178
17179
17180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17181   void * jresult ;
17182   Extents *arg1 = 0 ;
17183   Dali::Property::Value *result = 0 ;
17184
17185   arg1 = (Extents *)jarg1;
17186   if (!arg1) {
17187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17188     return 0;
17189   }
17190   {
17191     try {
17192       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17193     } catch (std::out_of_range& e) {
17194       {
17195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17196       };
17197     } catch (std::exception& e) {
17198       {
17199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (...) {
17202       {
17203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17204       };
17205     }
17206   }
17207   jresult = (void *)result;
17208   return jresult;
17209 }
17210
17211
17212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17213   void * jresult ;
17214   Dali::Property::Type arg1 ;
17215   Dali::Property::Value *result = 0 ;
17216
17217   arg1 = (Dali::Property::Type)jarg1;
17218   {
17219     try {
17220       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17221     } catch (std::out_of_range& e) {
17222       {
17223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (std::exception& e) {
17226       {
17227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (Dali::DaliException e) {
17230       {
17231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17232       };
17233     } catch (...) {
17234       {
17235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17236       };
17237     }
17238   }
17239
17240   jresult = (void *)result;
17241   return jresult;
17242 }
17243
17244
17245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17246   void * jresult ;
17247   Dali::Property::Value *arg1 = 0 ;
17248   Dali::Property::Value *result = 0 ;
17249
17250   arg1 = (Dali::Property::Value *)jarg1;
17251   if (!arg1) {
17252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17253     return 0;
17254   }
17255   {
17256     try {
17257       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17258     } catch (std::out_of_range& e) {
17259       {
17260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17261       };
17262     } catch (std::exception& e) {
17263       {
17264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17265       };
17266     } catch (Dali::DaliException e) {
17267       {
17268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17269       };
17270     } catch (...) {
17271       {
17272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17273       };
17274     }
17275   }
17276
17277   jresult = (void *)result;
17278   return jresult;
17279 }
17280
17281
17282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17283   void * jresult ;
17284   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17285   Dali::Property::Value *arg2 = 0 ;
17286   Dali::Property::Value *result = 0 ;
17287
17288   arg1 = (Dali::Property::Value *)jarg1;
17289   arg2 = (Dali::Property::Value *)jarg2;
17290   if (!arg2) {
17291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17292     return 0;
17293   }
17294   {
17295     try {
17296       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17297     } catch (std::out_of_range& e) {
17298       {
17299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17300       };
17301     } catch (std::exception& e) {
17302       {
17303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (Dali::DaliException e) {
17306       {
17307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17308       };
17309     } catch (...) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17312       };
17313     }
17314   }
17315
17316   jresult = (void *)result;
17317   return jresult;
17318 }
17319
17320
17321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17322   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17323
17324   arg1 = (Dali::Property::Value *)jarg1;
17325   {
17326     try {
17327       delete arg1;
17328     } catch (std::out_of_range& e) {
17329       {
17330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17331       };
17332     } catch (std::exception& e) {
17333       {
17334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17335       };
17336     } catch (Dali::DaliException e) {
17337       {
17338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17339       };
17340     } catch (...) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17343       };
17344     }
17345   }
17346
17347 }
17348
17349
17350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17351   int jresult ;
17352   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17353   Dali::Property::Type result;
17354
17355   arg1 = (Dali::Property::Value *)jarg1;
17356   {
17357     try {
17358       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17359     } catch (std::out_of_range& e) {
17360       {
17361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17362       };
17363     } catch (std::exception& e) {
17364       {
17365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (Dali::DaliException e) {
17368       {
17369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17370       };
17371     } catch (...) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17374       };
17375     }
17376   }
17377
17378   jresult = (int)result;
17379   return jresult;
17380 }
17381
17382
17383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17384   unsigned int jresult ;
17385   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17386   bool *arg2 = 0 ;
17387   bool result;
17388
17389   arg1 = (Dali::Property::Value *)jarg1;
17390   arg2 = (bool *)jarg2;
17391   {
17392     try {
17393       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17394     } catch (std::out_of_range& e) {
17395       {
17396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17397       };
17398     } catch (std::exception& e) {
17399       {
17400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17401       };
17402     } catch (Dali::DaliException e) {
17403       {
17404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17405       };
17406     } catch (...) {
17407       {
17408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17409       };
17410     }
17411   }
17412
17413   jresult = result;
17414   return jresult;
17415 }
17416
17417
17418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17419   unsigned int jresult ;
17420   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17421   float *arg2 = 0 ;
17422   bool result;
17423
17424   arg1 = (Dali::Property::Value *)jarg1;
17425   arg2 = (float *)jarg2;
17426   {
17427     try {
17428       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17429     } catch (std::out_of_range& e) {
17430       {
17431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17432       };
17433     } catch (std::exception& e) {
17434       {
17435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17436       };
17437     } catch (Dali::DaliException e) {
17438       {
17439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17440       };
17441     } catch (...) {
17442       {
17443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17444       };
17445     }
17446   }
17447
17448   jresult = result;
17449   return jresult;
17450 }
17451
17452
17453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17454   unsigned int jresult ;
17455   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17456   int *arg2 = 0 ;
17457   bool result;
17458
17459   arg1 = (Dali::Property::Value *)jarg1;
17460   arg2 = (int *)jarg2;
17461   {
17462     try {
17463       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17464     } catch (std::out_of_range& e) {
17465       {
17466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17467       };
17468     } catch (std::exception& e) {
17469       {
17470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17471       };
17472     } catch (Dali::DaliException e) {
17473       {
17474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17475       };
17476     } catch (...) {
17477       {
17478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17479       };
17480     }
17481   }
17482
17483   jresult = result;
17484   return jresult;
17485 }
17486
17487
17488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17489   unsigned int jresult ;
17490   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17491   Dali::Rect< int > *arg2 = 0 ;
17492   bool result;
17493
17494   arg1 = (Dali::Property::Value *)jarg1;
17495   arg2 = (Dali::Rect< int > *)jarg2;
17496   if (!arg2) {
17497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17498     return 0;
17499   }
17500   {
17501     try {
17502       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17503     } catch (std::out_of_range& e) {
17504       {
17505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17506       };
17507     } catch (std::exception& e) {
17508       {
17509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (Dali::DaliException e) {
17512       {
17513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17514       };
17515     } catch (...) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17518       };
17519     }
17520   }
17521
17522   jresult = result;
17523   return jresult;
17524 }
17525
17526
17527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17528   unsigned int jresult ;
17529   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17530   Dali::Vector2 *arg2 = 0 ;
17531   bool result;
17532
17533   arg1 = (Dali::Property::Value *)jarg1;
17534   arg2 = (Dali::Vector2 *)jarg2;
17535   if (!arg2) {
17536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17537     return 0;
17538   }
17539   {
17540     try {
17541       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17542     } catch (std::out_of_range& e) {
17543       {
17544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17545       };
17546     } catch (std::exception& e) {
17547       {
17548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17549       };
17550     } catch (Dali::DaliException e) {
17551       {
17552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17553       };
17554     } catch (...) {
17555       {
17556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17557       };
17558     }
17559   }
17560
17561   jresult = result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17567   unsigned int jresult ;
17568   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17569   Dali::Vector3 *arg2 = 0 ;
17570   bool result;
17571
17572   arg1 = (Dali::Property::Value *)jarg1;
17573   arg2 = (Dali::Vector3 *)jarg2;
17574   if (!arg2) {
17575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17576     return 0;
17577   }
17578   {
17579     try {
17580       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17581     } catch (std::out_of_range& e) {
17582       {
17583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (std::exception& e) {
17586       {
17587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (Dali::DaliException e) {
17590       {
17591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17592       };
17593     } catch (...) {
17594       {
17595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17596       };
17597     }
17598   }
17599
17600   jresult = result;
17601   return jresult;
17602 }
17603
17604
17605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17606   unsigned int jresult ;
17607   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17608   Dali::Vector4 *arg2 = 0 ;
17609   bool result;
17610
17611   arg1 = (Dali::Property::Value *)jarg1;
17612   arg2 = (Dali::Vector4 *)jarg2;
17613   if (!arg2) {
17614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17615     return 0;
17616   }
17617   {
17618     try {
17619       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17620     } catch (std::out_of_range& e) {
17621       {
17622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17623       };
17624     } catch (std::exception& e) {
17625       {
17626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (Dali::DaliException e) {
17629       {
17630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17631       };
17632     } catch (...) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17635       };
17636     }
17637   }
17638
17639   jresult = result;
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17645   unsigned int jresult ;
17646   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17647   Dali::Matrix3 *arg2 = 0 ;
17648   bool result;
17649
17650   arg1 = (Dali::Property::Value *)jarg1;
17651   arg2 = (Dali::Matrix3 *)jarg2;
17652   if (!arg2) {
17653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17654     return 0;
17655   }
17656   {
17657     try {
17658       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17659     } catch (std::out_of_range& e) {
17660       {
17661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17662       };
17663     } catch (std::exception& e) {
17664       {
17665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (Dali::DaliException e) {
17668       {
17669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17670       };
17671     } catch (...) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17674       };
17675     }
17676   }
17677
17678   jresult = result;
17679   return jresult;
17680 }
17681
17682
17683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17684   unsigned int jresult ;
17685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17686   Dali::Matrix *arg2 = 0 ;
17687   bool result;
17688
17689   arg1 = (Dali::Property::Value *)jarg1;
17690   arg2 = (Dali::Matrix *)jarg2;
17691   if (!arg2) {
17692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17693     return 0;
17694   }
17695   {
17696     try {
17697       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17698     } catch (std::out_of_range& e) {
17699       {
17700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17701       };
17702     } catch (std::exception& e) {
17703       {
17704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17705       };
17706     } catch (Dali::DaliException e) {
17707       {
17708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17709       };
17710     } catch (...) {
17711       {
17712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17713       };
17714     }
17715   }
17716
17717   jresult = result;
17718   return jresult;
17719 }
17720
17721
17722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17723   unsigned int jresult ;
17724   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17725   Dali::AngleAxis *arg2 = 0 ;
17726   bool result;
17727
17728   arg1 = (Dali::Property::Value *)jarg1;
17729   arg2 = (Dali::AngleAxis *)jarg2;
17730   if (!arg2) {
17731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17732     return 0;
17733   }
17734   {
17735     try {
17736       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17737     } catch (std::out_of_range& e) {
17738       {
17739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (std::exception& e) {
17742       {
17743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17744       };
17745     } catch (Dali::DaliException e) {
17746       {
17747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17748       };
17749     } catch (...) {
17750       {
17751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17752       };
17753     }
17754   }
17755
17756   jresult = result;
17757   return jresult;
17758 }
17759
17760
17761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17762   unsigned int jresult ;
17763   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17764   Dali::Quaternion *arg2 = 0 ;
17765   bool result;
17766
17767   arg1 = (Dali::Property::Value *)jarg1;
17768   arg2 = (Dali::Quaternion *)jarg2;
17769   if (!arg2) {
17770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17771     return 0;
17772   }
17773   {
17774     try {
17775       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17776     } catch (std::out_of_range& e) {
17777       {
17778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17779       };
17780     } catch (std::exception& e) {
17781       {
17782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17783       };
17784     } catch (Dali::DaliException e) {
17785       {
17786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17787       };
17788     } catch (...) {
17789       {
17790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17791       };
17792     }
17793   }
17794
17795   jresult = result;
17796   return jresult;
17797 }
17798
17799
17800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17801   unsigned int jresult ;
17802   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17803   std::string *arg2 = 0 ;
17804   bool result;
17805
17806   arg1 = (Dali::Property::Value *)jarg1;
17807
17808   //typemap in
17809   std::string temp;
17810   arg2 = &temp;
17811
17812   {
17813     try {
17814       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17815     } catch (std::out_of_range& e) {
17816       {
17817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17818       };
17819     } catch (std::exception& e) {
17820       {
17821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (Dali::DaliException e) {
17824       {
17825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17826       };
17827     } catch (...) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17830       };
17831     }
17832   }
17833
17834   jresult = result;
17835
17836   //Typemap argout in c++ file.
17837   //This will convert c++ string to c# string
17838   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17839
17840   return jresult;
17841 }
17842
17843
17844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17845   unsigned int jresult ;
17846   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17847   Dali::Property::Array *arg2 = 0 ;
17848   bool result;
17849
17850   arg1 = (Dali::Property::Value *)jarg1;
17851   arg2 = (Dali::Property::Array *)jarg2;
17852   if (!arg2) {
17853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17854     return 0;
17855   }
17856   {
17857     try {
17858       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17859     } catch (std::out_of_range& e) {
17860       {
17861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17862       };
17863     } catch (std::exception& e) {
17864       {
17865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17866       };
17867     } catch (Dali::DaliException e) {
17868       {
17869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17870       };
17871     } catch (...) {
17872       {
17873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17874       };
17875     }
17876   }
17877
17878   jresult = result;
17879   return jresult;
17880 }
17881
17882
17883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17884   unsigned int jresult ;
17885   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17886   Dali::Property::Map *arg2 = 0 ;
17887   bool result;
17888
17889   arg1 = (Dali::Property::Value *)jarg1;
17890   arg2 = (Dali::Property::Map *)jarg2;
17891   if (!arg2) {
17892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17893     return 0;
17894   }
17895   {
17896     try {
17897       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17898     } catch (std::out_of_range& e) {
17899       {
17900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17901       };
17902     } catch (std::exception& e) {
17903       {
17904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17905       };
17906     } catch (Dali::DaliException e) {
17907       {
17908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17909       };
17910     } catch (...) {
17911       {
17912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17913       };
17914     }
17915   }
17916
17917   jresult = result;
17918   return jresult;
17919 }
17920
17921
17922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17923   unsigned int jresult ;
17924   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17925   Extents *arg2 = 0 ;
17926   bool result;
17927
17928   arg1 = (Dali::Property::Value *)jarg1;
17929   arg2 = (Extents *)jarg2;
17930   if (!arg2) {
17931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17932     return 0;
17933   }
17934   {
17935     try {
17936       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17937     } catch (std::out_of_range& e) {
17938       {
17939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (std::exception& e) {
17942       {
17943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (...) {
17946       {
17947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17948       };
17949     }
17950   }
17951   jresult = result;
17952   return jresult;
17953 }
17954
17955
17956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17957   void * jresult ;
17958   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17959   Dali::Property::Array *result = 0 ;
17960
17961   arg1 = (Dali::Property::Value *)jarg1;
17962   {
17963     try {
17964       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17965     } catch (std::out_of_range& e) {
17966       {
17967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (std::exception& e) {
17970       {
17971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (Dali::DaliException e) {
17974       {
17975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17976       };
17977     } catch (...) {
17978       {
17979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17980       };
17981     }
17982   }
17983
17984   jresult = (void *)result;
17985   return jresult;
17986 }
17987
17988
17989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17990   void * jresult ;
17991   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17992   Dali::Property::Map *result = 0 ;
17993
17994   arg1 = (Dali::Property::Value *)jarg1;
17995   {
17996     try {
17997       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
17998     } catch (std::out_of_range& e) {
17999       {
18000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18001       };
18002     } catch (std::exception& e) {
18003       {
18004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18005       };
18006     } catch (Dali::DaliException e) {
18007       {
18008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18009       };
18010     } catch (...) {
18011       {
18012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18013       };
18014     }
18015   }
18016
18017   jresult = (void *)result;
18018   return jresult;
18019 }
18020
18021
18022 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18023   char * jresult ;
18024   Dali::Property::Type arg1 ;
18025   char *result = 0 ;
18026
18027   arg1 = (Dali::Property::Type)jarg1;
18028   {
18029     try {
18030       result = (char *)Dali::PropertyTypes::GetName(arg1);
18031     } catch (std::out_of_range& e) {
18032       {
18033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18034       };
18035     } catch (std::exception& e) {
18036       {
18037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (Dali::DaliException e) {
18040       {
18041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18042       };
18043     } catch (...) {
18044       {
18045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18046       };
18047     }
18048   }
18049
18050   jresult = SWIG_csharp_string_callback((const char *)result);
18051   return jresult;
18052 }
18053
18054
18055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18056   unsigned int jresult ;
18057   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18058   std::string *arg2 = 0 ;
18059   Dali::Property::Map *arg3 = 0 ;
18060   bool result;
18061
18062   arg1 = (Dali::BaseObject *)jarg1;
18063   if (!jarg2) {
18064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18065     return 0;
18066   }
18067   std::string arg2_str(jarg2);
18068   arg2 = &arg2_str;
18069   arg3 = (Dali::Property::Map *)jarg3;
18070   if (!arg3) {
18071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18072     return 0;
18073   }
18074   {
18075     try {
18076       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18077     } catch (std::out_of_range& e) {
18078       {
18079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18080       };
18081     } catch (std::exception& e) {
18082       {
18083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18084       };
18085     } catch (Dali::DaliException e) {
18086       {
18087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18088       };
18089     } catch (...) {
18090       {
18091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18092       };
18093     }
18094   }
18095
18096   jresult = result;
18097
18098   //argout typemap for const std::string&
18099
18100   return jresult;
18101 }
18102
18103
18104 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18105   char * jresult ;
18106   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18107   std::string *result = 0 ;
18108
18109   arg1 = (Dali::BaseObject *)jarg1;
18110   {
18111     try {
18112       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18113     } catch (std::out_of_range& e) {
18114       {
18115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18116       };
18117     } catch (std::exception& e) {
18118       {
18119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18120       };
18121     } catch (Dali::DaliException e) {
18122       {
18123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18124       };
18125     } catch (...) {
18126       {
18127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18128       };
18129     }
18130   }
18131
18132   jresult = SWIG_csharp_string_callback(result->c_str());
18133   return jresult;
18134 }
18135
18136
18137 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18138   unsigned int jresult ;
18139   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18140   Dali::TypeInfo *arg2 = 0 ;
18141   bool result;
18142
18143   arg1 = (Dali::BaseObject *)jarg1;
18144   arg2 = (Dali::TypeInfo *)jarg2;
18145   if (!arg2) {
18146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18147     return 0;
18148   }
18149   {
18150     try {
18151       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18152     } catch (std::out_of_range& e) {
18153       {
18154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18155       };
18156     } catch (std::exception& e) {
18157       {
18158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18159       };
18160     } catch (Dali::DaliException e) {
18161       {
18162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18163       };
18164     } catch (...) {
18165       {
18166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18167       };
18168     }
18169   }
18170
18171   jresult = result;
18172   return jresult;
18173 }
18174
18175
18176 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18177   unsigned int jresult ;
18178   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18179   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18180   std::string *arg3 = 0 ;
18181   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18182   bool result;
18183
18184   arg1 = (Dali::BaseObject *)jarg1;
18185   arg2 = (ConnectionTrackerInterface *)jarg2;
18186   if (!jarg3) {
18187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18188     return 0;
18189   }
18190   std::string arg3_str(jarg3);
18191   arg3 = &arg3_str;
18192   arg4 = (FunctorDelegate *)jarg4;
18193   {
18194     try {
18195       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18196     } catch (std::out_of_range& e) {
18197       {
18198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18199       };
18200     } catch (std::exception& e) {
18201       {
18202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18203       };
18204     } catch (Dali::DaliException e) {
18205       {
18206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18207       };
18208     } catch (...) {
18209       {
18210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18211       };
18212     }
18213   }
18214
18215   jresult = result;
18216
18217   //argout typemap for const std::string&
18218
18219   return jresult;
18220 }
18221
18222
18223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18224   void * jresult ;
18225   Dali::BaseHandle *arg1 = 0 ;
18226   Dali::BaseObject *result = 0 ;
18227
18228   arg1 = (Dali::BaseHandle *)jarg1;
18229   if (!arg1) {
18230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18231     return 0;
18232   }
18233   {
18234     try {
18235       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18236     } catch (std::out_of_range& e) {
18237       {
18238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18239       };
18240     } catch (std::exception& e) {
18241       {
18242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18243       };
18244     } catch (Dali::DaliException e) {
18245       {
18246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18247       };
18248     } catch (...) {
18249       {
18250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18251       };
18252     }
18253   }
18254
18255   jresult = (void *)result;
18256   return jresult;
18257 }
18258
18259
18260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18261   void * jresult ;
18262   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18263   Dali::BaseHandle *result = 0 ;
18264
18265   arg1 = (Dali::BaseObject *)jarg1;
18266   {
18267     try {
18268       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18269     } catch (std::out_of_range& e) {
18270       {
18271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18272       };
18273     } catch (std::exception& e) {
18274       {
18275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18276       };
18277     } catch (Dali::DaliException e) {
18278       {
18279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18280       };
18281     } catch (...) {
18282       {
18283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18284       };
18285     }
18286   }
18287
18288   jresult = (void *)result;
18289   return jresult;
18290 }
18291
18292
18293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18294   void * jresult ;
18295   Dali::BaseHandle *result = 0 ;
18296
18297   {
18298     try {
18299       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18300     } catch (std::out_of_range& e) {
18301       {
18302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18303       };
18304     } catch (std::exception& e) {
18305       {
18306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18307       };
18308     } catch (Dali::DaliException e) {
18309       {
18310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18311       };
18312     } catch (...) {
18313       {
18314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18315       };
18316     }
18317   }
18318
18319   jresult = (void *)result;
18320   return jresult;
18321 }
18322
18323
18324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18325   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18326
18327   arg1 = (Dali::BaseHandle *)jarg1;
18328   {
18329     try {
18330       delete arg1;
18331     } catch (std::out_of_range& e) {
18332       {
18333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18334       };
18335     } catch (std::exception& e) {
18336       {
18337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18338       };
18339     } catch (Dali::DaliException e) {
18340       {
18341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18342       };
18343     } catch (...) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18346       };
18347     }
18348   }
18349
18350 }
18351
18352
18353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18354   void * jresult ;
18355   Dali::BaseHandle *arg1 = 0 ;
18356   Dali::BaseHandle *result = 0 ;
18357
18358   arg1 = (Dali::BaseHandle *)jarg1;
18359   if (!arg1) {
18360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18361     return 0;
18362   }
18363   {
18364     try {
18365       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18366     } catch (std::out_of_range& e) {
18367       {
18368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18369       };
18370     } catch (std::exception& e) {
18371       {
18372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18373       };
18374     } catch (Dali::DaliException e) {
18375       {
18376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18377       };
18378     } catch (...) {
18379       {
18380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18381       };
18382     }
18383   }
18384
18385   jresult = (void *)result;
18386   return jresult;
18387 }
18388
18389
18390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18391   void * jresult ;
18392   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18393   Dali::BaseHandle *arg2 = 0 ;
18394   Dali::BaseHandle *result = 0 ;
18395
18396   arg1 = (Dali::BaseHandle *)jarg1;
18397   arg2 = (Dali::BaseHandle *)jarg2;
18398   if (!arg2) {
18399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18400     return 0;
18401   }
18402   {
18403     try {
18404       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18405     } catch (std::out_of_range& e) {
18406       {
18407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18408       };
18409     } catch (std::exception& e) {
18410       {
18411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18412       };
18413     } catch (Dali::DaliException e) {
18414       {
18415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18416       };
18417     } catch (...) {
18418       {
18419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18420       };
18421     }
18422   }
18423
18424   jresult = (void *)result;
18425   return jresult;
18426 }
18427
18428
18429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18430   unsigned int jresult ;
18431   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18432   std::string *arg2 = 0 ;
18433   Dali::Property::Map *arg3 = 0 ;
18434   bool result;
18435
18436   arg1 = (Dali::BaseHandle *)jarg1;
18437   if (!jarg2) {
18438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18439     return 0;
18440   }
18441   std::string arg2_str(jarg2);
18442   arg2 = &arg2_str;
18443   arg3 = (Dali::Property::Map *)jarg3;
18444   if (!arg3) {
18445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18446     return 0;
18447   }
18448   {
18449     try {
18450       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18451     } catch (std::out_of_range& e) {
18452       {
18453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18454       };
18455     } catch (std::exception& e) {
18456       {
18457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18458       };
18459     } catch (Dali::DaliException e) {
18460       {
18461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18462       };
18463     } catch (...) {
18464       {
18465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18466       };
18467     }
18468   }
18469
18470   jresult = result;
18471
18472   //argout typemap for const std::string&
18473
18474   return jresult;
18475 }
18476
18477
18478 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18479   char * jresult ;
18480   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18481   std::string *result = 0 ;
18482
18483   arg1 = (Dali::BaseHandle *)jarg1;
18484   {
18485     try {
18486       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18487     } catch (std::out_of_range& e) {
18488       {
18489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18490       };
18491     } catch (std::exception& e) {
18492       {
18493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18494       };
18495     } catch (Dali::DaliException e) {
18496       {
18497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18498       };
18499     } catch (...) {
18500       {
18501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18502       };
18503     }
18504   }
18505
18506   jresult = SWIG_csharp_string_callback(result->c_str());
18507   return jresult;
18508 }
18509
18510
18511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18512   unsigned int jresult ;
18513   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18514   Dali::TypeInfo *arg2 = 0 ;
18515   bool result;
18516
18517   arg1 = (Dali::BaseHandle *)jarg1;
18518   arg2 = (Dali::TypeInfo *)jarg2;
18519   if (!arg2) {
18520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18521     return 0;
18522   }
18523   {
18524     try {
18525       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18526     } catch (std::out_of_range& e) {
18527       {
18528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18529       };
18530     } catch (std::exception& e) {
18531       {
18532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18533       };
18534     } catch (Dali::DaliException e) {
18535       {
18536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18537       };
18538     } catch (...) {
18539       {
18540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18541       };
18542     }
18543   }
18544
18545   jresult = result;
18546   return jresult;
18547 }
18548
18549
18550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18551   void * jresult ;
18552   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18553   Dali::BaseObject *result = 0 ;
18554
18555   arg1 = (Dali::BaseHandle *)jarg1;
18556   {
18557     try {
18558       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18559     } catch (std::out_of_range& e) {
18560       {
18561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18562       };
18563     } catch (std::exception& e) {
18564       {
18565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18566       };
18567     } catch (Dali::DaliException e) {
18568       {
18569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18570       };
18571     } catch (...) {
18572       {
18573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18574       };
18575     }
18576   }
18577
18578   jresult = (void *)result;
18579   return jresult;
18580 }
18581
18582
18583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18584   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18585
18586   arg1 = (Dali::BaseHandle *)jarg1;
18587   {
18588     try {
18589       (arg1)->Reset();
18590     } catch (std::out_of_range& e) {
18591       {
18592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18593       };
18594     } catch (std::exception& e) {
18595       {
18596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18597       };
18598     } catch (Dali::DaliException e) {
18599       {
18600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18601       };
18602     } catch (...) {
18603       {
18604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18605       };
18606     }
18607   }
18608
18609 }
18610
18611
18612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18613   unsigned int jresult ;
18614   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18615   Dali::BaseHandle *arg2 = 0 ;
18616   bool result;
18617
18618   arg1 = (Dali::BaseHandle *)jarg1;
18619   arg2 = (Dali::BaseHandle *)jarg2;
18620   if (!arg2) {
18621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18622     return 0;
18623   }
18624   {
18625     try {
18626       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18627     } catch (std::out_of_range& e) {
18628       {
18629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18630       };
18631     } catch (std::exception& e) {
18632       {
18633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18634       };
18635     } catch (Dali::DaliException e) {
18636       {
18637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18638       };
18639     } catch (...) {
18640       {
18641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18642       };
18643     }
18644   }
18645
18646   jresult = result;
18647   return jresult;
18648 }
18649
18650
18651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18652   unsigned int jresult ;
18653   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18654   Dali::BaseHandle *arg2 = 0 ;
18655   bool result;
18656
18657   arg1 = (Dali::BaseHandle *)jarg1;
18658   arg2 = (Dali::BaseHandle *)jarg2;
18659   if (!arg2) {
18660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18661     return 0;
18662   }
18663   {
18664     try {
18665       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18666     } catch (std::out_of_range& e) {
18667       {
18668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18669       };
18670     } catch (std::exception& e) {
18671       {
18672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18673       };
18674     } catch (Dali::DaliException e) {
18675       {
18676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18677       };
18678     } catch (...) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18681       };
18682     }
18683   }
18684
18685   jresult = result;
18686   return jresult;
18687 }
18688
18689
18690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18691   void * jresult ;
18692   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18693   Dali::RefObject *result = 0 ;
18694
18695   arg1 = (Dali::BaseHandle *)jarg1;
18696   {
18697     try {
18698       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18699     } catch (std::out_of_range& e) {
18700       {
18701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18702       };
18703     } catch (std::exception& e) {
18704       {
18705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18706       };
18707     } catch (Dali::DaliException e) {
18708       {
18709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18710       };
18711     } catch (...) {
18712       {
18713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18714       };
18715     }
18716   }
18717
18718   jresult = (void *)result;
18719   return jresult;
18720 }
18721
18722
18723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18724   unsigned int jresult ;
18725   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18726   bool result;
18727
18728   arg1 = (Dali::BaseHandle *)jarg1;
18729   {
18730     try {
18731       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18732     } catch (std::out_of_range& e) {
18733       {
18734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18735       };
18736     } catch (std::exception& e) {
18737       {
18738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (Dali::DaliException e) {
18741       {
18742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18743       };
18744     } catch (...) {
18745       {
18746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18747       };
18748     }
18749   }
18750
18751   jresult = result;
18752   return jresult;
18753 }
18754
18755
18756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18757   unsigned int jresult ;
18758   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18759   Dali::BaseHandle *arg2 = 0 ;
18760   bool result;
18761
18762   arg1 = (Dali::BaseHandle *)jarg1;
18763   arg2 = (Dali::BaseHandle *)jarg2;
18764   if (!arg2) {
18765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18766     return 0;
18767   }
18768   {
18769     try {
18770       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18771     } catch (std::out_of_range& e) {
18772       {
18773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18774       };
18775     } catch (std::exception& e) {
18776       {
18777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18778       };
18779     } catch (Dali::DaliException e) {
18780       {
18781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18782       };
18783     } catch (...) {
18784       {
18785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18786       };
18787     }
18788   }
18789
18790   jresult = result;
18791   return jresult;
18792 }
18793
18794
18795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18796   unsigned int jresult ;
18797   Dali::BaseHandle *arg1 = 0 ;
18798   Dali::BaseHandle *arg2 = 0 ;
18799   bool result;
18800
18801   arg1 = (Dali::BaseHandle *)jarg1;
18802   if (!arg1) {
18803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18804     return 0;
18805   }
18806   arg2 = (Dali::BaseHandle *)jarg2;
18807   if (!arg2) {
18808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18809     return 0;
18810   }
18811   {
18812     try {
18813       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18814     } catch (std::out_of_range& e) {
18815       {
18816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (std::exception& e) {
18819       {
18820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (Dali::DaliException e) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18825       };
18826     } catch (...) {
18827       {
18828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18829       };
18830     }
18831   }
18832
18833   jresult = result;
18834   return jresult;
18835 }
18836
18837
18838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18839   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18840
18841   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18842   {
18843     try {
18844       delete arg1;
18845     } catch (std::out_of_range& e) {
18846       {
18847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18848       };
18849     } catch (std::exception& e) {
18850       {
18851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18852       };
18853     } catch (Dali::DaliException e) {
18854       {
18855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18856       };
18857     } catch (...) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18860       };
18861     }
18862   }
18863
18864 }
18865
18866
18867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18868   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18869   SlotObserver *arg2 = (SlotObserver *) 0 ;
18870   CallbackBase *arg3 = (CallbackBase *) 0 ;
18871
18872   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18873   arg2 = (SlotObserver *)jarg2;
18874   arg3 = (CallbackBase *)jarg3;
18875   {
18876     try {
18877       (arg1)->SignalConnected(arg2,arg3);
18878     } catch (std::out_of_range& e) {
18879       {
18880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18881       };
18882     } catch (std::exception& e) {
18883       {
18884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18885       };
18886     } catch (Dali::DaliException e) {
18887       {
18888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18889       };
18890     } catch (...) {
18891       {
18892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18893       };
18894     }
18895   }
18896
18897 }
18898
18899
18900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18901   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18902
18903   arg1 = (Dali::SignalObserver *)jarg1;
18904   {
18905     try {
18906       delete arg1;
18907     } catch (std::out_of_range& e) {
18908       {
18909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18910       };
18911     } catch (std::exception& e) {
18912       {
18913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18914       };
18915     } catch (Dali::DaliException e) {
18916       {
18917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18918       };
18919     } catch (...) {
18920       {
18921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18922       };
18923     }
18924   }
18925
18926 }
18927
18928
18929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18930   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18931   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18932   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18933
18934   arg1 = (Dali::SignalObserver *)jarg1;
18935   arg2 = (Dali::SlotObserver *)jarg2;
18936   arg3 = (Dali::CallbackBase *)jarg3;
18937   {
18938     try {
18939       (arg1)->SignalDisconnected(arg2,arg3);
18940     } catch (std::out_of_range& e) {
18941       {
18942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18943       };
18944     } catch (std::exception& e) {
18945       {
18946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18947       };
18948     } catch (Dali::DaliException e) {
18949       {
18950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18951       };
18952     } catch (...) {
18953       {
18954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18955       };
18956     }
18957   }
18958
18959 }
18960
18961
18962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18963   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18964
18965   arg1 = (Dali::SlotObserver *)jarg1;
18966   {
18967     try {
18968       delete arg1;
18969     } catch (std::out_of_range& e) {
18970       {
18971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18972       };
18973     } catch (std::exception& e) {
18974       {
18975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18976       };
18977     } catch (Dali::DaliException e) {
18978       {
18979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18980       };
18981     } catch (...) {
18982       {
18983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18984       };
18985     }
18986   }
18987
18988 }
18989
18990
18991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18992   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18993   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18994
18995   arg1 = (Dali::SlotObserver *)jarg1;
18996   arg2 = (Dali::CallbackBase *)jarg2;
18997   {
18998     try {
18999       (arg1)->SlotDisconnected(arg2);
19000     } catch (std::out_of_range& e) {
19001       {
19002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19003       };
19004     } catch (std::exception& e) {
19005       {
19006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19007       };
19008     } catch (Dali::DaliException e) {
19009       {
19010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19011       };
19012     } catch (...) {
19013       {
19014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19015       };
19016     }
19017   }
19018
19019 }
19020
19021
19022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19023   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19024
19025   arg1 = (Dali::ConnectionTracker *)jarg1;
19026   {
19027     try {
19028       delete arg1;
19029     } catch (std::out_of_range& e) {
19030       {
19031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19032       };
19033     } catch (std::exception& e) {
19034       {
19035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19036       };
19037     } catch (Dali::DaliException e) {
19038       {
19039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19040       };
19041     } catch (...) {
19042       {
19043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19044       };
19045     }
19046   }
19047
19048 }
19049
19050
19051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19052   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19053
19054   arg1 = (Dali::ConnectionTracker *)jarg1;
19055   {
19056     try {
19057       (arg1)->DisconnectAll();
19058     } catch (std::out_of_range& e) {
19059       {
19060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19061       };
19062     } catch (std::exception& e) {
19063       {
19064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19065       };
19066     } catch (Dali::DaliException e) {
19067       {
19068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19069       };
19070     } catch (...) {
19071       {
19072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19073       };
19074     }
19075   }
19076
19077 }
19078
19079
19080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19081   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19082   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19083   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19084
19085   arg1 = (Dali::ConnectionTracker *)jarg1;
19086   arg2 = (Dali::SlotObserver *)jarg2;
19087   arg3 = (Dali::CallbackBase *)jarg3;
19088   {
19089     try {
19090       (arg1)->SignalConnected(arg2,arg3);
19091     } catch (std::out_of_range& e) {
19092       {
19093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19094       };
19095     } catch (std::exception& e) {
19096       {
19097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (Dali::DaliException e) {
19100       {
19101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19102       };
19103     } catch (...) {
19104       {
19105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19106       };
19107     }
19108   }
19109
19110 }
19111
19112
19113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19114   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19115   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19116   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19117
19118   arg1 = (Dali::ConnectionTracker *)jarg1;
19119   arg2 = (Dali::SlotObserver *)jarg2;
19120   arg3 = (Dali::CallbackBase *)jarg3;
19121   {
19122     try {
19123       (arg1)->SignalDisconnected(arg2,arg3);
19124     } catch (std::out_of_range& e) {
19125       {
19126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19127       };
19128     } catch (std::exception& e) {
19129       {
19130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19131       };
19132     } catch (Dali::DaliException e) {
19133       {
19134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19135       };
19136     } catch (...) {
19137       {
19138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19139       };
19140     }
19141   }
19142
19143 }
19144
19145
19146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19147   unsigned long jresult ;
19148   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19149   std::size_t result;
19150
19151   arg1 = (Dali::ConnectionTracker *)jarg1;
19152   {
19153     try {
19154       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19155     } catch (std::out_of_range& e) {
19156       {
19157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19158       };
19159     } catch (std::exception& e) {
19160       {
19161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (Dali::DaliException e) {
19164       {
19165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19166       };
19167     } catch (...) {
19168       {
19169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19170       };
19171     }
19172   }
19173
19174   jresult = (unsigned long)result;
19175   return jresult;
19176 }
19177
19178
19179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19180   void * jresult ;
19181   Dali::ObjectRegistry *result = 0 ;
19182
19183   {
19184     try {
19185       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19186     } catch (std::out_of_range& e) {
19187       {
19188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19189       };
19190     } catch (std::exception& e) {
19191       {
19192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (Dali::DaliException e) {
19195       {
19196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19197       };
19198     } catch (...) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19201       };
19202     }
19203   }
19204
19205   jresult = (void *)result;
19206   return jresult;
19207 }
19208
19209
19210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19211   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19212
19213   arg1 = (Dali::ObjectRegistry *)jarg1;
19214   {
19215     try {
19216       delete arg1;
19217     } catch (std::out_of_range& e) {
19218       {
19219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19220       };
19221     } catch (std::exception& e) {
19222       {
19223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19224       };
19225     } catch (Dali::DaliException e) {
19226       {
19227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19228       };
19229     } catch (...) {
19230       {
19231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19232       };
19233     }
19234   }
19235
19236 }
19237
19238
19239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19240   void * jresult ;
19241   Dali::ObjectRegistry *arg1 = 0 ;
19242   Dali::ObjectRegistry *result = 0 ;
19243
19244   arg1 = (Dali::ObjectRegistry *)jarg1;
19245   if (!arg1) {
19246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19247     return 0;
19248   }
19249   {
19250     try {
19251       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19252     } catch (std::out_of_range& e) {
19253       {
19254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19255       };
19256     } catch (std::exception& e) {
19257       {
19258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (Dali::DaliException e) {
19261       {
19262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19263       };
19264     } catch (...) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19267       };
19268     }
19269   }
19270
19271   jresult = (void *)result;
19272   return jresult;
19273 }
19274
19275
19276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19277   void * jresult ;
19278   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19279   Dali::ObjectRegistry *arg2 = 0 ;
19280   Dali::ObjectRegistry *result = 0 ;
19281
19282   arg1 = (Dali::ObjectRegistry *)jarg1;
19283   arg2 = (Dali::ObjectRegistry *)jarg2;
19284   if (!arg2) {
19285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19286     return 0;
19287   }
19288   {
19289     try {
19290       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19291     } catch (std::out_of_range& e) {
19292       {
19293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19294       };
19295     } catch (std::exception& e) {
19296       {
19297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (Dali::DaliException e) {
19300       {
19301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19302       };
19303     } catch (...) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19306       };
19307     }
19308   }
19309
19310   jresult = (void *)result;
19311   return jresult;
19312 }
19313
19314
19315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19316   void * jresult ;
19317   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19318   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19319
19320   arg1 = (Dali::ObjectRegistry *)jarg1;
19321   {
19322     try {
19323       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19324     } catch (std::out_of_range& e) {
19325       {
19326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19327       };
19328     } catch (std::exception& e) {
19329       {
19330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19331       };
19332     } catch (Dali::DaliException e) {
19333       {
19334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19335       };
19336     } catch (...) {
19337       {
19338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19339       };
19340     }
19341   }
19342
19343   jresult = (void *)result;
19344   return jresult;
19345 }
19346
19347
19348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19349   void * jresult ;
19350   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19351   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19352
19353   arg1 = (Dali::ObjectRegistry *)jarg1;
19354   {
19355     try {
19356       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19357     } catch (std::out_of_range& e) {
19358       {
19359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19360       };
19361     } catch (std::exception& e) {
19362       {
19363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19364       };
19365     } catch (Dali::DaliException e) {
19366       {
19367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19368       };
19369     } catch (...) {
19370       {
19371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19372       };
19373     }
19374   }
19375
19376   jresult = (void *)result;
19377   return jresult;
19378 }
19379
19380
19381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19382   void * jresult ;
19383   Dali::PropertyCondition *result = 0 ;
19384
19385   {
19386     try {
19387       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19388     } catch (std::out_of_range& e) {
19389       {
19390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19391       };
19392     } catch (std::exception& e) {
19393       {
19394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19395       };
19396     } catch (Dali::DaliException e) {
19397       {
19398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19399       };
19400     } catch (...) {
19401       {
19402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19403       };
19404     }
19405   }
19406
19407   jresult = (void *)result;
19408   return jresult;
19409 }
19410
19411
19412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19413   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19414
19415   arg1 = (Dali::PropertyCondition *)jarg1;
19416   {
19417     try {
19418       delete arg1;
19419     } catch (std::out_of_range& e) {
19420       {
19421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19422       };
19423     } catch (std::exception& e) {
19424       {
19425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19426       };
19427     } catch (Dali::DaliException e) {
19428       {
19429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19430       };
19431     } catch (...) {
19432       {
19433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19434       };
19435     }
19436   }
19437
19438 }
19439
19440
19441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19442   void * jresult ;
19443   Dali::PropertyCondition *arg1 = 0 ;
19444   Dali::PropertyCondition *result = 0 ;
19445
19446   arg1 = (Dali::PropertyCondition *)jarg1;
19447   if (!arg1) {
19448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19449     return 0;
19450   }
19451   {
19452     try {
19453       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19454     } catch (std::out_of_range& e) {
19455       {
19456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19457       };
19458     } catch (std::exception& e) {
19459       {
19460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19461       };
19462     } catch (Dali::DaliException e) {
19463       {
19464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19465       };
19466     } catch (...) {
19467       {
19468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19469       };
19470     }
19471   }
19472
19473   jresult = (void *)result;
19474   return jresult;
19475 }
19476
19477
19478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19479   void * jresult ;
19480   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19481   Dali::PropertyCondition *arg2 = 0 ;
19482   Dali::PropertyCondition *result = 0 ;
19483
19484   arg1 = (Dali::PropertyCondition *)jarg1;
19485   arg2 = (Dali::PropertyCondition *)jarg2;
19486   if (!arg2) {
19487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19488     return 0;
19489   }
19490   {
19491     try {
19492       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19493     } catch (std::out_of_range& e) {
19494       {
19495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19496       };
19497     } catch (std::exception& e) {
19498       {
19499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19500       };
19501     } catch (Dali::DaliException e) {
19502       {
19503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19504       };
19505     } catch (...) {
19506       {
19507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19508       };
19509     }
19510   }
19511
19512   jresult = (void *)result;
19513   return jresult;
19514 }
19515
19516
19517 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19518   unsigned long jresult ;
19519   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19520   std::size_t result;
19521
19522   arg1 = (Dali::PropertyCondition *)jarg1;
19523   {
19524     try {
19525       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19526     } catch (std::out_of_range& e) {
19527       {
19528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19529       };
19530     } catch (std::exception& e) {
19531       {
19532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19533       };
19534     } catch (...) {
19535       {
19536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19537       };
19538     }
19539   }
19540   jresult = (unsigned long)result;
19541   return jresult;
19542 }
19543
19544
19545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19546   float jresult ;
19547   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19548   std::size_t arg2 ;
19549   float result;
19550
19551   arg1 = (Dali::PropertyCondition *)jarg1;
19552   arg2 = (std::size_t)jarg2;
19553   {
19554     try {
19555       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19556     } catch (std::out_of_range& e) {
19557       {
19558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19559       };
19560     } catch (std::exception& e) {
19561       {
19562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19563       };
19564     } catch (...) {
19565       {
19566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19567       };
19568     }
19569   }
19570   jresult = result;
19571   return jresult;
19572 }
19573
19574
19575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19576   void * jresult ;
19577   float arg1 ;
19578   Dali::PropertyCondition result;
19579
19580   arg1 = (float)jarg1;
19581   {
19582     try {
19583       result = Dali::LessThanCondition(arg1);
19584     } catch (std::out_of_range& e) {
19585       {
19586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (std::exception& e) {
19589       {
19590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (Dali::DaliException e) {
19593       {
19594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19595       };
19596     } catch (...) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19599       };
19600     }
19601   }
19602
19603   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19604   return jresult;
19605 }
19606
19607
19608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19609   void * jresult ;
19610   float arg1 ;
19611   Dali::PropertyCondition result;
19612
19613   arg1 = (float)jarg1;
19614   {
19615     try {
19616       result = Dali::GreaterThanCondition(arg1);
19617     } catch (std::out_of_range& e) {
19618       {
19619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19620       };
19621     } catch (std::exception& e) {
19622       {
19623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19624       };
19625     } catch (Dali::DaliException e) {
19626       {
19627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19628       };
19629     } catch (...) {
19630       {
19631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19632       };
19633     }
19634   }
19635
19636   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19637   return jresult;
19638 }
19639
19640
19641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19642   void * jresult ;
19643   float arg1 ;
19644   float arg2 ;
19645   Dali::PropertyCondition result;
19646
19647   arg1 = (float)jarg1;
19648   arg2 = (float)jarg2;
19649   {
19650     try {
19651       result = Dali::InsideCondition(arg1,arg2);
19652     } catch (std::out_of_range& e) {
19653       {
19654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19655       };
19656     } catch (std::exception& e) {
19657       {
19658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19659       };
19660     } catch (Dali::DaliException e) {
19661       {
19662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19663       };
19664     } catch (...) {
19665       {
19666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19667       };
19668     }
19669   }
19670
19671   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19672   return jresult;
19673 }
19674
19675
19676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19677   void * jresult ;
19678   float arg1 ;
19679   float arg2 ;
19680   Dali::PropertyCondition result;
19681
19682   arg1 = (float)jarg1;
19683   arg2 = (float)jarg2;
19684   {
19685     try {
19686       result = Dali::OutsideCondition(arg1,arg2);
19687     } catch (std::out_of_range& e) {
19688       {
19689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19690       };
19691     } catch (std::exception& e) {
19692       {
19693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19694       };
19695     } catch (Dali::DaliException e) {
19696       {
19697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19698       };
19699     } catch (...) {
19700       {
19701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19702       };
19703     }
19704   }
19705
19706   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19707   return jresult;
19708 }
19709
19710
19711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19712   void * jresult ;
19713   float arg1 ;
19714   float arg2 ;
19715   Dali::PropertyCondition result;
19716
19717   arg1 = (float)jarg1;
19718   arg2 = (float)jarg2;
19719   {
19720     try {
19721       result = Dali::StepCondition(arg1,arg2);
19722     } catch (std::out_of_range& e) {
19723       {
19724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19725       };
19726     } catch (std::exception& e) {
19727       {
19728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19729       };
19730     } catch (Dali::DaliException e) {
19731       {
19732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19733       };
19734     } catch (...) {
19735       {
19736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19737       };
19738     }
19739   }
19740
19741   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19742   return jresult;
19743 }
19744
19745
19746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19747   void * jresult ;
19748   float arg1 ;
19749   Dali::PropertyCondition result;
19750
19751   arg1 = (float)jarg1;
19752   {
19753     try {
19754       result = Dali::StepCondition(arg1);
19755     } catch (std::out_of_range& e) {
19756       {
19757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19758       };
19759     } catch (std::exception& e) {
19760       {
19761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19762       };
19763     } catch (Dali::DaliException e) {
19764       {
19765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19766       };
19767     } catch (...) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19770       };
19771     }
19772   }
19773
19774   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19775   return jresult;
19776 }
19777
19778
19779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19780   void * jresult ;
19781   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19782   Dali::PropertyCondition result;
19783
19784   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19785   if (!arg1) {
19786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19787     return 0;
19788   }
19789   {
19790     try {
19791       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19792     } catch (std::out_of_range& e) {
19793       {
19794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19795       };
19796     } catch (std::exception& e) {
19797       {
19798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (Dali::DaliException e) {
19801       {
19802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19803       };
19804     } catch (...) {
19805       {
19806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19807       };
19808     }
19809   }
19810
19811   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19812   return jresult;
19813 }
19814
19815
19816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19817   void * jresult ;
19818   Dali::PropertyNotification *result = 0 ;
19819
19820   {
19821     try {
19822       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19823     } catch (std::out_of_range& e) {
19824       {
19825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19826       };
19827     } catch (std::exception& e) {
19828       {
19829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19830       };
19831     } catch (Dali::DaliException e) {
19832       {
19833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19834       };
19835     } catch (...) {
19836       {
19837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19838       };
19839     }
19840   }
19841
19842   jresult = (void *)result;
19843   return jresult;
19844 }
19845
19846
19847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19848   void * jresult ;
19849   Dali::BaseHandle arg1 ;
19850   Dali::BaseHandle *argp1 ;
19851   Dali::PropertyNotification result;
19852
19853   argp1 = (Dali::BaseHandle *)jarg1;
19854   if (!argp1) {
19855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19856     return 0;
19857   }
19858   arg1 = *argp1;
19859   {
19860     try {
19861       result = Dali::PropertyNotification::DownCast(arg1);
19862     } catch (std::out_of_range& e) {
19863       {
19864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19865       };
19866     } catch (std::exception& e) {
19867       {
19868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19869       };
19870     } catch (Dali::DaliException e) {
19871       {
19872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19873       };
19874     } catch (...) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19877       };
19878     }
19879   }
19880
19881   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19882   return jresult;
19883 }
19884
19885
19886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19887   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19888
19889   arg1 = (Dali::PropertyNotification *)jarg1;
19890   {
19891     try {
19892       delete arg1;
19893     } catch (std::out_of_range& e) {
19894       {
19895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19896       };
19897     } catch (std::exception& e) {
19898       {
19899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19900       };
19901     } catch (Dali::DaliException e) {
19902       {
19903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19904       };
19905     } catch (...) {
19906       {
19907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19908       };
19909     }
19910   }
19911
19912 }
19913
19914
19915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19916   void * jresult ;
19917   Dali::PropertyNotification *arg1 = 0 ;
19918   Dali::PropertyNotification *result = 0 ;
19919
19920   arg1 = (Dali::PropertyNotification *)jarg1;
19921   if (!arg1) {
19922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19923     return 0;
19924   }
19925   {
19926     try {
19927       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19928     } catch (std::out_of_range& e) {
19929       {
19930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19931       };
19932     } catch (std::exception& e) {
19933       {
19934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (Dali::DaliException e) {
19937       {
19938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19939       };
19940     } catch (...) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19943       };
19944     }
19945   }
19946
19947   jresult = (void *)result;
19948   return jresult;
19949 }
19950
19951
19952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19953   void * jresult ;
19954   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19955   Dali::PropertyNotification *arg2 = 0 ;
19956   Dali::PropertyNotification *result = 0 ;
19957
19958   arg1 = (Dali::PropertyNotification *)jarg1;
19959   arg2 = (Dali::PropertyNotification *)jarg2;
19960   if (!arg2) {
19961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19962     return 0;
19963   }
19964   {
19965     try {
19966       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19967     } catch (std::out_of_range& e) {
19968       {
19969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19970       };
19971     } catch (std::exception& e) {
19972       {
19973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19974       };
19975     } catch (Dali::DaliException e) {
19976       {
19977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19978       };
19979     } catch (...) {
19980       {
19981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19982       };
19983     }
19984   }
19985
19986   jresult = (void *)result;
19987   return jresult;
19988 }
19989
19990
19991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19992   void * jresult ;
19993   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19994   Dali::PropertyCondition result;
19995
19996   arg1 = (Dali::PropertyNotification *)jarg1;
19997   {
19998     try {
19999       result = (arg1)->GetCondition();
20000     } catch (std::out_of_range& e) {
20001       {
20002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20003       };
20004     } catch (std::exception& e) {
20005       {
20006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20007       };
20008     } catch (Dali::DaliException e) {
20009       {
20010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20011       };
20012     } catch (...) {
20013       {
20014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20015       };
20016     }
20017   }
20018
20019   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20020   return jresult;
20021 }
20022
20023
20024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20025   void * jresult ;
20026   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20027   Dali::Handle result;
20028
20029   arg1 = (Dali::PropertyNotification *)jarg1;
20030   {
20031     try {
20032       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20033     } catch (std::out_of_range& e) {
20034       {
20035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20036       };
20037     } catch (std::exception& e) {
20038       {
20039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20040       };
20041     } catch (Dali::DaliException e) {
20042       {
20043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20044       };
20045     } catch (...) {
20046       {
20047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20048       };
20049     }
20050   }
20051
20052   jresult = new Dali::Handle((const Dali::Handle &)result);
20053   return jresult;
20054 }
20055
20056
20057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20058   int jresult ;
20059   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20060   Dali::Property::Index result;
20061
20062   arg1 = (Dali::PropertyNotification *)jarg1;
20063   {
20064     try {
20065       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20066     } catch (std::out_of_range& e) {
20067       {
20068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20069       };
20070     } catch (std::exception& e) {
20071       {
20072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (Dali::DaliException e) {
20075       {
20076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20077       };
20078     } catch (...) {
20079       {
20080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20081       };
20082     }
20083   }
20084
20085   jresult = result;
20086   return jresult;
20087 }
20088
20089
20090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20091   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20092   Dali::PropertyNotification::NotifyMode arg2 ;
20093
20094   arg1 = (Dali::PropertyNotification *)jarg1;
20095   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20096   {
20097     try {
20098       (arg1)->SetNotifyMode(arg2);
20099     } catch (std::out_of_range& e) {
20100       {
20101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20102       };
20103     } catch (std::exception& e) {
20104       {
20105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20106       };
20107     } catch (Dali::DaliException e) {
20108       {
20109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20110       };
20111     } catch (...) {
20112       {
20113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20114       };
20115     }
20116   }
20117
20118 }
20119
20120
20121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20122   int jresult ;
20123   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20124   Dali::PropertyNotification::NotifyMode result;
20125
20126   arg1 = (Dali::PropertyNotification *)jarg1;
20127   {
20128     try {
20129       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20130     } catch (std::out_of_range& e) {
20131       {
20132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20133       };
20134     } catch (std::exception& e) {
20135       {
20136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20137       };
20138     } catch (Dali::DaliException e) {
20139       {
20140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20141       };
20142     } catch (...) {
20143       {
20144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20145       };
20146     }
20147   }
20148
20149   jresult = (int)result;
20150   return jresult;
20151 }
20152
20153
20154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20155   unsigned int jresult ;
20156   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20157   bool result;
20158
20159   arg1 = (Dali::PropertyNotification *)jarg1;
20160   {
20161     try {
20162       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20163     } catch (std::out_of_range& e) {
20164       {
20165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20166       };
20167     } catch (std::exception& e) {
20168       {
20169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20170       };
20171     } catch (Dali::DaliException e) {
20172       {
20173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20174       };
20175     } catch (...) {
20176       {
20177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20178       };
20179     }
20180   }
20181
20182   jresult = result;
20183   return jresult;
20184 }
20185
20186
20187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20188   void * jresult ;
20189   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20190   Dali::PropertyNotifySignalType *result = 0 ;
20191
20192   arg1 = (Dali::PropertyNotification *)jarg1;
20193   {
20194     try {
20195       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20196     } catch (std::out_of_range& e) {
20197       {
20198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20199       };
20200     } catch (std::exception& e) {
20201       {
20202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20203       };
20204     } catch (Dali::DaliException e) {
20205       {
20206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20207       };
20208     } catch (...) {
20209       {
20210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20211       };
20212     }
20213   }
20214
20215   jresult = (void *)result;
20216   return jresult;
20217 }
20218
20219
20220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20221   void * jresult ;
20222   Dali::Handle *result = 0 ;
20223
20224   {
20225     try {
20226       result = (Dali::Handle *)new Dali::Handle();
20227     } catch (std::out_of_range& e) {
20228       {
20229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20230       };
20231     } catch (std::exception& e) {
20232       {
20233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20234       };
20235     } catch (Dali::DaliException e) {
20236       {
20237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20238       };
20239     } catch (...) {
20240       {
20241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20242       };
20243     }
20244   }
20245
20246   jresult = (void *)result;
20247   return jresult;
20248 }
20249
20250
20251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20252   void * jresult ;
20253   Dali::Handle result;
20254
20255   {
20256     try {
20257       result = Dali::Handle::New();
20258     } catch (std::out_of_range& e) {
20259       {
20260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20261       };
20262     } catch (std::exception& e) {
20263       {
20264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (Dali::DaliException e) {
20267       {
20268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20269       };
20270     } catch (...) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20273       };
20274     }
20275   }
20276
20277   jresult = new Dali::Handle((const Dali::Handle &)result);
20278   return jresult;
20279 }
20280
20281
20282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20283   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20284
20285   arg1 = (Dali::Handle *)jarg1;
20286   {
20287     try {
20288       delete arg1;
20289     } catch (std::out_of_range& e) {
20290       {
20291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20292       };
20293     } catch (std::exception& e) {
20294       {
20295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20296       };
20297     } catch (Dali::DaliException e) {
20298       {
20299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20300       };
20301     } catch (...) {
20302       {
20303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20304       };
20305     }
20306   }
20307
20308 }
20309
20310
20311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20312   void * jresult ;
20313   Dali::Handle *arg1 = 0 ;
20314   Dali::Handle *result = 0 ;
20315
20316   arg1 = (Dali::Handle *)jarg1;
20317   if (!arg1) {
20318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20319     return 0;
20320   }
20321   {
20322     try {
20323       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20324     } catch (std::out_of_range& e) {
20325       {
20326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20327       };
20328     } catch (std::exception& e) {
20329       {
20330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20331       };
20332     } catch (Dali::DaliException e) {
20333       {
20334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20335       };
20336     } catch (...) {
20337       {
20338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20339       };
20340     }
20341   }
20342
20343   jresult = (void *)result;
20344   return jresult;
20345 }
20346
20347
20348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20349   void * jresult ;
20350   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20351   Dali::Handle *arg2 = 0 ;
20352   Dali::Handle *result = 0 ;
20353
20354   arg1 = (Dali::Handle *)jarg1;
20355   arg2 = (Dali::Handle *)jarg2;
20356   if (!arg2) {
20357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20358     return 0;
20359   }
20360   {
20361     try {
20362       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20363     } catch (std::out_of_range& e) {
20364       {
20365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20366       };
20367     } catch (std::exception& e) {
20368       {
20369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20370       };
20371     } catch (Dali::DaliException e) {
20372       {
20373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20374       };
20375     } catch (...) {
20376       {
20377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20378       };
20379     }
20380   }
20381
20382   jresult = (void *)result;
20383   return jresult;
20384 }
20385
20386
20387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20388   void * jresult ;
20389   Dali::BaseHandle arg1 ;
20390   Dali::BaseHandle *argp1 ;
20391   Dali::Handle result;
20392
20393   argp1 = (Dali::BaseHandle *)jarg1;
20394   if (!argp1) {
20395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20396     return 0;
20397   }
20398   arg1 = *argp1;
20399   {
20400     try {
20401       result = Dali::Handle::DownCast(arg1);
20402     } catch (std::out_of_range& e) {
20403       {
20404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20405       };
20406     } catch (std::exception& e) {
20407       {
20408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20409       };
20410     } catch (Dali::DaliException e) {
20411       {
20412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20413       };
20414     } catch (...) {
20415       {
20416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20417       };
20418     }
20419   }
20420
20421   jresult = new Dali::Handle((const Dali::Handle &)result);
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20427   unsigned int jresult ;
20428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20429   Dali::Handle::Capability arg2 ;
20430   bool result;
20431
20432   arg1 = (Dali::Handle *)jarg1;
20433   arg2 = (Dali::Handle::Capability)jarg2;
20434   {
20435     try {
20436       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20437     } catch (std::out_of_range& e) {
20438       {
20439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20440       };
20441     } catch (std::exception& e) {
20442       {
20443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20444       };
20445     } catch (Dali::DaliException e) {
20446       {
20447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20448       };
20449     } catch (...) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20452       };
20453     }
20454   }
20455
20456   jresult = result;
20457   return jresult;
20458 }
20459
20460
20461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20462   unsigned int jresult ;
20463   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20464   unsigned int result;
20465
20466   arg1 = (Dali::Handle *)jarg1;
20467   {
20468     try {
20469       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20470     } catch (std::out_of_range& e) {
20471       {
20472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20473       };
20474     } catch (std::exception& e) {
20475       {
20476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20477       };
20478     } catch (Dali::DaliException e) {
20479       {
20480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20481       };
20482     } catch (...) {
20483       {
20484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20485       };
20486     }
20487   }
20488
20489   jresult = result;
20490   return jresult;
20491 }
20492
20493
20494 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20495   char * jresult ;
20496   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20497   Dali::Property::Index arg2 ;
20498   std::string result;
20499
20500   arg1 = (Dali::Handle *)jarg1;
20501   arg2 = (Dali::Property::Index)jarg2;
20502   {
20503     try {
20504       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20505     } catch (std::out_of_range& e) {
20506       {
20507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20508       };
20509     } catch (std::exception& e) {
20510       {
20511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20512       };
20513     } catch (Dali::DaliException e) {
20514       {
20515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20516       };
20517     } catch (...) {
20518       {
20519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20520       };
20521     }
20522   }
20523
20524   jresult = SWIG_csharp_string_callback((&result)->c_str());
20525   return jresult;
20526 }
20527
20528
20529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20530   int jresult ;
20531   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20532   std::string *arg2 = 0 ;
20533   Dali::Property::Index result;
20534
20535   arg1 = (Dali::Handle *)jarg1;
20536   if (!jarg2) {
20537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20538     return 0;
20539   }
20540   std::string arg2_str(jarg2);
20541   arg2 = &arg2_str;
20542   {
20543     try {
20544       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20545     } catch (std::out_of_range& e) {
20546       {
20547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20548       };
20549     } catch (std::exception& e) {
20550       {
20551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20552       };
20553     } catch (Dali::DaliException e) {
20554       {
20555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20556       };
20557     } catch (...) {
20558       {
20559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20560       };
20561     }
20562   }
20563
20564   jresult = result;
20565
20566   //argout typemap for const std::string&
20567
20568   return jresult;
20569 }
20570
20571
20572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20573   unsigned int jresult ;
20574   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20575   Dali::Property::Index arg2 ;
20576   bool result;
20577
20578   arg1 = (Dali::Handle *)jarg1;
20579   arg2 = (Dali::Property::Index)jarg2;
20580   {
20581     try {
20582       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20583     } catch (std::out_of_range& e) {
20584       {
20585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20586       };
20587     } catch (std::exception& e) {
20588       {
20589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (Dali::DaliException e) {
20592       {
20593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20594       };
20595     } catch (...) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20598       };
20599     }
20600   }
20601
20602   jresult = result;
20603   return jresult;
20604 }
20605
20606
20607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20608   unsigned int jresult ;
20609   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20610   Dali::Property::Index arg2 ;
20611   bool result;
20612
20613   arg1 = (Dali::Handle *)jarg1;
20614   arg2 = (Dali::Property::Index)jarg2;
20615   {
20616     try {
20617       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20618     } catch (std::out_of_range& e) {
20619       {
20620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20621       };
20622     } catch (std::exception& e) {
20623       {
20624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20625       };
20626     } catch (Dali::DaliException e) {
20627       {
20628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20629       };
20630     } catch (...) {
20631       {
20632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20633       };
20634     }
20635   }
20636
20637   jresult = result;
20638   return jresult;
20639 }
20640
20641
20642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20643   unsigned int jresult ;
20644   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20645   Dali::Property::Index arg2 ;
20646   bool result;
20647
20648   arg1 = (Dali::Handle *)jarg1;
20649   arg2 = (Dali::Property::Index)jarg2;
20650   {
20651     try {
20652       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20653     } catch (std::out_of_range& e) {
20654       {
20655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20656       };
20657     } catch (std::exception& e) {
20658       {
20659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20660       };
20661     } catch (Dali::DaliException e) {
20662       {
20663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20664       };
20665     } catch (...) {
20666       {
20667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20668       };
20669     }
20670   }
20671
20672   jresult = result;
20673   return jresult;
20674 }
20675
20676
20677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20678   int jresult ;
20679   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20680   Dali::Property::Index arg2 ;
20681   Dali::Property::Type result;
20682
20683   arg1 = (Dali::Handle *)jarg1;
20684   arg2 = (Dali::Property::Index)jarg2;
20685   {
20686     try {
20687       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20688     } catch (std::out_of_range& e) {
20689       {
20690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20691       };
20692     } catch (std::exception& e) {
20693       {
20694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20695       };
20696     } catch (Dali::DaliException e) {
20697       {
20698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20699       };
20700     } catch (...) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20703       };
20704     }
20705   }
20706
20707   jresult = (int)result;
20708   return jresult;
20709 }
20710
20711
20712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20713   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20714   Dali::Property::Index arg2 ;
20715   Dali::Property::Value *arg3 = 0 ;
20716
20717   arg1 = (Dali::Handle *)jarg1;
20718   arg2 = (Dali::Property::Index)jarg2;
20719   arg3 = (Dali::Property::Value *)jarg3;
20720   if (!arg3) {
20721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20722     return ;
20723   }
20724   {
20725     try {
20726       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20727     } catch (std::out_of_range& e) {
20728       {
20729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20730       };
20731     } catch (std::exception& e) {
20732       {
20733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20734       };
20735     } catch (Dali::DaliException e) {
20736       {
20737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20738       };
20739     } catch (...) {
20740       {
20741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20742       };
20743     }
20744   }
20745
20746 }
20747
20748
20749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20750   int jresult ;
20751   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20752   std::string *arg2 = 0 ;
20753   Dali::Property::Value *arg3 = 0 ;
20754   Dali::Property::Index result;
20755
20756   arg1 = (Dali::Handle *)jarg1;
20757   if (!jarg2) {
20758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20759     return 0;
20760   }
20761   std::string arg2_str(jarg2);
20762   arg2 = &arg2_str;
20763   arg3 = (Dali::Property::Value *)jarg3;
20764   if (!arg3) {
20765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20766     return 0;
20767   }
20768   {
20769     try {
20770       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20771     } catch (std::out_of_range& e) {
20772       {
20773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20774       };
20775     } catch (std::exception& e) {
20776       {
20777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20778       };
20779     } catch (Dali::DaliException e) {
20780       {
20781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20782       };
20783     } catch (...) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20786       };
20787     }
20788   }
20789
20790   jresult = result;
20791
20792   //argout typemap for const std::string&
20793
20794   return jresult;
20795 }
20796
20797
20798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20799   int jresult ;
20800   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20801   std::string *arg2 = 0 ;
20802   Dali::Property::Value *arg3 = 0 ;
20803   Dali::Property::AccessMode arg4 ;
20804   Dali::Property::Index result;
20805
20806   arg1 = (Dali::Handle *)jarg1;
20807   if (!jarg2) {
20808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20809     return 0;
20810   }
20811   std::string arg2_str(jarg2);
20812   arg2 = &arg2_str;
20813   arg3 = (Dali::Property::Value *)jarg3;
20814   if (!arg3) {
20815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20816     return 0;
20817   }
20818   arg4 = (Dali::Property::AccessMode)jarg4;
20819   {
20820     try {
20821       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20822     } catch (std::out_of_range& e) {
20823       {
20824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20825       };
20826     } catch (std::exception& e) {
20827       {
20828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (Dali::DaliException e) {
20831       {
20832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20833       };
20834     } catch (...) {
20835       {
20836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20837       };
20838     }
20839   }
20840
20841   jresult = result;
20842
20843   //argout typemap for const std::string&
20844
20845   return jresult;
20846 }
20847
20848
20849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20850   void * jresult ;
20851   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20852   Dali::Property::Index arg2 ;
20853   Dali::Property::Value result;
20854
20855   arg1 = (Dali::Handle *)jarg1;
20856   arg2 = (Dali::Property::Index)jarg2;
20857   {
20858     try {
20859       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20860     } catch (std::out_of_range& e) {
20861       {
20862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20863       };
20864     } catch (std::exception& e) {
20865       {
20866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (Dali::DaliException e) {
20869       {
20870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20871       };
20872     } catch (...) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20875       };
20876     }
20877   }
20878
20879   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20880   return jresult;
20881 }
20882
20883
20884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20885   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20886   Dali::Property::IndexContainer *arg2 = 0 ;
20887
20888   arg1 = (Dali::Handle *)jarg1;
20889   arg2 = (Dali::Property::IndexContainer *)jarg2;
20890   if (!arg2) {
20891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20892     return ;
20893   }
20894   {
20895     try {
20896       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20897     } catch (std::out_of_range& e) {
20898       {
20899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20900       };
20901     } catch (std::exception& e) {
20902       {
20903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20904       };
20905     } catch (Dali::DaliException e) {
20906       {
20907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20908       };
20909     } catch (...) {
20910       {
20911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20912       };
20913     }
20914   }
20915
20916 }
20917
20918
20919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20920   void * jresult ;
20921   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20922   Dali::Property::Index arg2 ;
20923   Dali::PropertyCondition *arg3 = 0 ;
20924   Dali::PropertyNotification result;
20925
20926   arg1 = (Dali::Handle *)jarg1;
20927   arg2 = (Dali::Property::Index)jarg2;
20928   arg3 = (Dali::PropertyCondition *)jarg3;
20929   if (!arg3) {
20930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20931     return 0;
20932   }
20933   {
20934     try {
20935       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20936     } catch (std::out_of_range& e) {
20937       {
20938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20939       };
20940     } catch (std::exception& e) {
20941       {
20942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (Dali::DaliException e) {
20945       {
20946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20947       };
20948     } catch (...) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20951       };
20952     }
20953   }
20954
20955   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20956   return jresult;
20957 }
20958
20959
20960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20961   void * jresult ;
20962   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20963   Dali::Property::Index arg2 ;
20964   int arg3 ;
20965   Dali::PropertyCondition *arg4 = 0 ;
20966   Dali::PropertyNotification result;
20967
20968   arg1 = (Dali::Handle *)jarg1;
20969   arg2 = (Dali::Property::Index)jarg2;
20970   arg3 = (int)jarg3;
20971   arg4 = (Dali::PropertyCondition *)jarg4;
20972   if (!arg4) {
20973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20974     return 0;
20975   }
20976   {
20977     try {
20978       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20979     } catch (std::out_of_range& e) {
20980       {
20981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20982       };
20983     } catch (std::exception& e) {
20984       {
20985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (Dali::DaliException e) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20990       };
20991     } catch (...) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20994       };
20995     }
20996   }
20997
20998   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20999   return jresult;
21000 }
21001
21002
21003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21004   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21005   Dali::PropertyNotification arg2 ;
21006   Dali::PropertyNotification *argp2 ;
21007
21008   arg1 = (Dali::Handle *)jarg1;
21009   argp2 = (Dali::PropertyNotification *)jarg2;
21010   if (!argp2) {
21011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21012     return ;
21013   }
21014   arg2 = *argp2;
21015   {
21016     try {
21017       (arg1)->RemovePropertyNotification(arg2);
21018     } catch (std::out_of_range& e) {
21019       {
21020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21021       };
21022     } catch (std::exception& e) {
21023       {
21024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21025       };
21026     } catch (Dali::DaliException e) {
21027       {
21028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21029       };
21030     } catch (...) {
21031       {
21032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21033       };
21034     }
21035   }
21036
21037 }
21038
21039
21040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21041   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21042
21043   arg1 = (Dali::Handle *)jarg1;
21044   {
21045     try {
21046       (arg1)->RemovePropertyNotifications();
21047     } catch (std::out_of_range& e) {
21048       {
21049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21050       };
21051     } catch (std::exception& e) {
21052       {
21053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21054       };
21055     } catch (Dali::DaliException e) {
21056       {
21057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21058       };
21059     } catch (...) {
21060       {
21061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21062       };
21063     }
21064   }
21065
21066 }
21067
21068
21069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21070   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21071
21072   arg1 = (Dali::Handle *)jarg1;
21073   {
21074     try {
21075       (arg1)->RemoveConstraints();
21076     } catch (std::out_of_range& e) {
21077       {
21078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21079       };
21080     } catch (std::exception& e) {
21081       {
21082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (Dali::DaliException e) {
21085       {
21086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21087       };
21088     } catch (...) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21091       };
21092     }
21093   }
21094
21095 }
21096
21097
21098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21099   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21100   unsigned int arg2 ;
21101
21102   arg1 = (Dali::Handle *)jarg1;
21103   arg2 = (unsigned int)jarg2;
21104   {
21105     try {
21106       (arg1)->RemoveConstraints(arg2);
21107     } catch (std::out_of_range& e) {
21108       {
21109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21110       };
21111     } catch (std::exception& e) {
21112       {
21113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21114       };
21115     } catch (Dali::DaliException e) {
21116       {
21117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21118       };
21119     } catch (...) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21122       };
21123     }
21124   }
21125
21126 }
21127
21128
21129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21130   int jresult ;
21131   Dali::Property::Index result;
21132
21133   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21134   jresult = result;
21135   return jresult;
21136 }
21137
21138
21139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21140   void * jresult ;
21141   Dali::Handle result;
21142
21143   {
21144     try {
21145       result = Dali::WeightObject::New();
21146     } catch (std::out_of_range& e) {
21147       {
21148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21149       };
21150     } catch (std::exception& e) {
21151       {
21152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21153       };
21154     } catch (Dali::DaliException e) {
21155       {
21156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21157       };
21158     } catch (...) {
21159       {
21160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21161       };
21162     }
21163   }
21164
21165   jresult = new Dali::Handle((const Dali::Handle &)result);
21166   return jresult;
21167 }
21168
21169
21170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21171   void * jresult ;
21172   Dali::TypeInfo *result = 0 ;
21173
21174   {
21175     try {
21176       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21177     } catch (std::out_of_range& e) {
21178       {
21179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21180       };
21181     } catch (std::exception& e) {
21182       {
21183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21184       };
21185     } catch (Dali::DaliException e) {
21186       {
21187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21188       };
21189     } catch (...) {
21190       {
21191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21192       };
21193     }
21194   }
21195
21196   jresult = (void *)result;
21197   return jresult;
21198 }
21199
21200
21201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21202   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21203
21204   arg1 = (Dali::TypeInfo *)jarg1;
21205   {
21206     try {
21207       delete arg1;
21208     } catch (std::out_of_range& e) {
21209       {
21210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21211       };
21212     } catch (std::exception& e) {
21213       {
21214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21215       };
21216     } catch (Dali::DaliException e) {
21217       {
21218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21219       };
21220     } catch (...) {
21221       {
21222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21223       };
21224     }
21225   }
21226
21227 }
21228
21229
21230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21231   void * jresult ;
21232   Dali::TypeInfo *arg1 = 0 ;
21233   Dali::TypeInfo *result = 0 ;
21234
21235   arg1 = (Dali::TypeInfo *)jarg1;
21236   if (!arg1) {
21237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21238     return 0;
21239   }
21240   {
21241     try {
21242       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21243     } catch (std::out_of_range& e) {
21244       {
21245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21246       };
21247     } catch (std::exception& e) {
21248       {
21249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21250       };
21251     } catch (Dali::DaliException e) {
21252       {
21253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21254       };
21255     } catch (...) {
21256       {
21257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21258       };
21259     }
21260   }
21261
21262   jresult = (void *)result;
21263   return jresult;
21264 }
21265
21266
21267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21268   void * jresult ;
21269   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21270   Dali::TypeInfo *arg2 = 0 ;
21271   Dali::TypeInfo *result = 0 ;
21272
21273   arg1 = (Dali::TypeInfo *)jarg1;
21274   arg2 = (Dali::TypeInfo *)jarg2;
21275   if (!arg2) {
21276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21277     return 0;
21278   }
21279   {
21280     try {
21281       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21282     } catch (std::out_of_range& e) {
21283       {
21284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21285       };
21286     } catch (std::exception& e) {
21287       {
21288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21289       };
21290     } catch (Dali::DaliException e) {
21291       {
21292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21293       };
21294     } catch (...) {
21295       {
21296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21297       };
21298     }
21299   }
21300
21301   jresult = (void *)result;
21302   return jresult;
21303 }
21304
21305
21306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21307   char * jresult ;
21308   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21309   std::string *result = 0 ;
21310
21311   arg1 = (Dali::TypeInfo *)jarg1;
21312   {
21313     try {
21314       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21315     } catch (std::out_of_range& e) {
21316       {
21317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21318       };
21319     } catch (std::exception& e) {
21320       {
21321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21322       };
21323     } catch (Dali::DaliException e) {
21324       {
21325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21326       };
21327     } catch (...) {
21328       {
21329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21330       };
21331     }
21332   }
21333
21334   jresult = SWIG_csharp_string_callback(result->c_str());
21335   return jresult;
21336 }
21337
21338
21339 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21340   char * jresult ;
21341   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21342   std::string *result = 0 ;
21343
21344   arg1 = (Dali::TypeInfo *)jarg1;
21345   {
21346     try {
21347       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21348     } catch (std::out_of_range& e) {
21349       {
21350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21351       };
21352     } catch (std::exception& e) {
21353       {
21354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (Dali::DaliException e) {
21357       {
21358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21359       };
21360     } catch (...) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21363       };
21364     }
21365   }
21366
21367   jresult = SWIG_csharp_string_callback(result->c_str());
21368   return jresult;
21369 }
21370
21371
21372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21373   void * jresult ;
21374   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21375   Dali::BaseHandle result;
21376
21377   arg1 = (Dali::TypeInfo *)jarg1;
21378   {
21379     try {
21380       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21381     } catch (std::out_of_range& e) {
21382       {
21383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21384       };
21385     } catch (std::exception& e) {
21386       {
21387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (Dali::DaliException e) {
21390       {
21391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21392       };
21393     } catch (...) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21396       };
21397     }
21398   }
21399
21400   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21401   return jresult;
21402 }
21403
21404
21405 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21406   unsigned long jresult ;
21407   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21408   size_t result;
21409
21410   arg1 = (Dali::TypeInfo *)jarg1;
21411   {
21412     try {
21413       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21414     } catch (std::out_of_range& e) {
21415       {
21416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21417       };
21418     } catch (std::exception& e) {
21419       {
21420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21421       };
21422     } catch (Dali::DaliException e) {
21423       {
21424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21425       };
21426     } catch (...) {
21427       {
21428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21429       };
21430     }
21431   }
21432
21433   jresult = (unsigned long)result;
21434   return jresult;
21435 }
21436
21437
21438 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21439   char * jresult ;
21440   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21441   size_t arg2 ;
21442   std::string result;
21443
21444   arg1 = (Dali::TypeInfo *)jarg1;
21445   arg2 = (size_t)jarg2;
21446   {
21447     try {
21448       result = (arg1)->GetActionName(arg2);
21449     } catch (std::out_of_range& e) {
21450       {
21451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21452       };
21453     } catch (std::exception& e) {
21454       {
21455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (Dali::DaliException e) {
21458       {
21459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21460       };
21461     } catch (...) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21464       };
21465     }
21466   }
21467
21468   jresult = SWIG_csharp_string_callback((&result)->c_str());
21469   return jresult;
21470 }
21471
21472
21473 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21474   unsigned long jresult ;
21475   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21476   size_t result;
21477
21478   arg1 = (Dali::TypeInfo *)jarg1;
21479   {
21480     try {
21481       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21482     } catch (std::out_of_range& e) {
21483       {
21484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21485       };
21486     } catch (std::exception& e) {
21487       {
21488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (Dali::DaliException e) {
21491       {
21492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21493       };
21494     } catch (...) {
21495       {
21496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21497       };
21498     }
21499   }
21500
21501   jresult = (unsigned long)result;
21502   return jresult;
21503 }
21504
21505
21506 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21507   char * jresult ;
21508   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21509   size_t arg2 ;
21510   std::string result;
21511
21512   arg1 = (Dali::TypeInfo *)jarg1;
21513   arg2 = (size_t)jarg2;
21514   {
21515     try {
21516       result = (arg1)->GetSignalName(arg2);
21517     } catch (std::out_of_range& e) {
21518       {
21519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21520       };
21521     } catch (std::exception& e) {
21522       {
21523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21524       };
21525     } catch (Dali::DaliException e) {
21526       {
21527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21528       };
21529     } catch (...) {
21530       {
21531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21532       };
21533     }
21534   }
21535
21536   jresult = SWIG_csharp_string_callback((&result)->c_str());
21537   return jresult;
21538 }
21539
21540
21541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21542   unsigned long jresult ;
21543   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21544   size_t result;
21545
21546   arg1 = (Dali::TypeInfo *)jarg1;
21547   {
21548     try {
21549       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21550     } catch (std::out_of_range& e) {
21551       {
21552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21553       };
21554     } catch (std::exception& e) {
21555       {
21556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21557       };
21558     } catch (Dali::DaliException e) {
21559       {
21560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21561       };
21562     } catch (...) {
21563       {
21564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21565       };
21566     }
21567   }
21568
21569   jresult = (unsigned long)result;
21570   return jresult;
21571 }
21572
21573
21574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21575   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21576   Dali::Property::IndexContainer *arg2 = 0 ;
21577
21578   arg1 = (Dali::TypeInfo *)jarg1;
21579   arg2 = (Dali::Property::IndexContainer *)jarg2;
21580   if (!arg2) {
21581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21582     return ;
21583   }
21584   {
21585     try {
21586       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21587     } catch (std::out_of_range& e) {
21588       {
21589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21590       };
21591     } catch (std::exception& e) {
21592       {
21593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21594       };
21595     } catch (Dali::DaliException e) {
21596       {
21597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21598       };
21599     } catch (...) {
21600       {
21601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21602       };
21603     }
21604   }
21605
21606 }
21607
21608
21609 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21610   char * jresult ;
21611   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21612   Dali::Property::Index arg2 ;
21613   std::string *result = 0 ;
21614
21615   arg1 = (Dali::TypeInfo *)jarg1;
21616   arg2 = (Dali::Property::Index)jarg2;
21617   {
21618     try {
21619       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21620     } catch (std::out_of_range& e) {
21621       {
21622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21623       };
21624     } catch (std::exception& e) {
21625       {
21626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21627       };
21628     } catch (Dali::DaliException e) {
21629       {
21630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21631       };
21632     } catch (...) {
21633       {
21634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21635       };
21636     }
21637   }
21638
21639   jresult = SWIG_csharp_string_callback(result->c_str());
21640   return jresult;
21641 }
21642
21643
21644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21645   void * jresult ;
21646   Dali::TypeRegistry result;
21647
21648   {
21649     try {
21650       result = Dali::TypeRegistry::Get();
21651     } catch (std::out_of_range& e) {
21652       {
21653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21654       };
21655     } catch (std::exception& e) {
21656       {
21657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (Dali::DaliException e) {
21660       {
21661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21662       };
21663     } catch (...) {
21664       {
21665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21666       };
21667     }
21668   }
21669
21670   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21671   return jresult;
21672 }
21673
21674
21675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21676   void * jresult ;
21677   Dali::TypeRegistry *result = 0 ;
21678
21679   {
21680     try {
21681       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21682     } catch (std::out_of_range& e) {
21683       {
21684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21685       };
21686     } catch (std::exception& e) {
21687       {
21688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21689       };
21690     } catch (Dali::DaliException e) {
21691       {
21692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21693       };
21694     } catch (...) {
21695       {
21696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21697       };
21698     }
21699   }
21700
21701   jresult = (void *)result;
21702   return jresult;
21703 }
21704
21705
21706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21707   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21708
21709   arg1 = (Dali::TypeRegistry *)jarg1;
21710   {
21711     try {
21712       delete arg1;
21713     } catch (std::out_of_range& e) {
21714       {
21715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21716       };
21717     } catch (std::exception& e) {
21718       {
21719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21720       };
21721     } catch (Dali::DaliException e) {
21722       {
21723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21724       };
21725     } catch (...) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21728       };
21729     }
21730   }
21731
21732 }
21733
21734
21735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21736   void * jresult ;
21737   Dali::TypeRegistry *arg1 = 0 ;
21738   Dali::TypeRegistry *result = 0 ;
21739
21740   arg1 = (Dali::TypeRegistry *)jarg1;
21741   if (!arg1) {
21742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21743     return 0;
21744   }
21745   {
21746     try {
21747       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21748     } catch (std::out_of_range& e) {
21749       {
21750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21751       };
21752     } catch (std::exception& e) {
21753       {
21754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (Dali::DaliException e) {
21757       {
21758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21759       };
21760     } catch (...) {
21761       {
21762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21763       };
21764     }
21765   }
21766
21767   jresult = (void *)result;
21768   return jresult;
21769 }
21770
21771
21772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21773   void * jresult ;
21774   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21775   Dali::TypeRegistry *arg2 = 0 ;
21776   Dali::TypeRegistry *result = 0 ;
21777
21778   arg1 = (Dali::TypeRegistry *)jarg1;
21779   arg2 = (Dali::TypeRegistry *)jarg2;
21780   if (!arg2) {
21781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21782     return 0;
21783   }
21784   {
21785     try {
21786       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21787     } catch (std::out_of_range& e) {
21788       {
21789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21790       };
21791     } catch (std::exception& e) {
21792       {
21793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21794       };
21795     } catch (Dali::DaliException e) {
21796       {
21797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21798       };
21799     } catch (...) {
21800       {
21801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21802       };
21803     }
21804   }
21805
21806   jresult = (void *)result;
21807   return jresult;
21808 }
21809
21810
21811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21812   void * jresult ;
21813   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21814   std::string *arg2 = 0 ;
21815   Dali::TypeInfo result;
21816
21817   arg1 = (Dali::TypeRegistry *)jarg1;
21818   if (!jarg2) {
21819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21820     return 0;
21821   }
21822   std::string arg2_str(jarg2);
21823   arg2 = &arg2_str;
21824   {
21825     try {
21826       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21827     } catch (std::out_of_range& e) {
21828       {
21829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21830       };
21831     } catch (std::exception& e) {
21832       {
21833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (Dali::DaliException e) {
21836       {
21837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21838       };
21839     } catch (...) {
21840       {
21841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21842       };
21843     }
21844   }
21845
21846   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21847
21848   //argout typemap for const std::string&
21849
21850   return jresult;
21851 }
21852
21853
21854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21855   void * jresult ;
21856   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21857   std::type_info *arg2 = 0 ;
21858   Dali::TypeInfo result;
21859
21860   arg1 = (Dali::TypeRegistry *)jarg1;
21861   arg2 = (std::type_info *)jarg2;
21862   if (!arg2) {
21863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21864     return 0;
21865   }
21866   {
21867     try {
21868       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21869     } catch (std::out_of_range& e) {
21870       {
21871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (std::exception& e) {
21874       {
21875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (Dali::DaliException e) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21880       };
21881     } catch (...) {
21882       {
21883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21884       };
21885     }
21886   }
21887
21888   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21889   return jresult;
21890 }
21891
21892
21893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21894   unsigned long jresult ;
21895   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21896   size_t result;
21897
21898   arg1 = (Dali::TypeRegistry *)jarg1;
21899   {
21900     try {
21901       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21902     } catch (std::out_of_range& e) {
21903       {
21904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21905       };
21906     } catch (std::exception& e) {
21907       {
21908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (Dali::DaliException e) {
21911       {
21912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21913       };
21914     } catch (...) {
21915       {
21916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21917       };
21918     }
21919   }
21920
21921   jresult = (unsigned long)result;
21922   return jresult;
21923 }
21924
21925
21926 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21927   char * jresult ;
21928   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21929   size_t arg2 ;
21930   std::string result;
21931
21932   arg1 = (Dali::TypeRegistry *)jarg1;
21933   arg2 = (size_t)jarg2;
21934   {
21935     try {
21936       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21937     } catch (std::out_of_range& e) {
21938       {
21939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21940       };
21941     } catch (std::exception& e) {
21942       {
21943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21944       };
21945     } catch (Dali::DaliException e) {
21946       {
21947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21948       };
21949     } catch (...) {
21950       {
21951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21952       };
21953     }
21954   }
21955
21956   jresult = SWIG_csharp_string_callback((&result)->c_str());
21957   return jresult;
21958 }
21959
21960
21961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_2(void * jarg1) {
21962   void * jresult ;
21963   Dali::Internal::TypeRegistry *arg1 = (Dali::Internal::TypeRegistry *) 0 ;
21964   Dali::TypeRegistry *result = 0 ;
21965
21966   arg1 = (Dali::Internal::TypeRegistry *)jarg1;
21967   {
21968     try {
21969       result = (Dali::TypeRegistry *)new Dali::TypeRegistry(arg1);
21970     } catch (std::out_of_range& e) {
21971       {
21972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21973       };
21974     } catch (std::exception& e) {
21975       {
21976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21977       };
21978     } catch (Dali::DaliException e) {
21979       {
21980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21981       };
21982     } catch (...) {
21983       {
21984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21985       };
21986     }
21987   }
21988
21989   jresult = (void *)result;
21990   return jresult;
21991 }
21992
21993
21994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21995   void * jresult ;
21996   std::type_info *arg1 = 0 ;
21997   std::type_info *arg2 = 0 ;
21998   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21999   Dali::TypeRegistration *result = 0 ;
22000
22001   arg1 = (std::type_info *)jarg1;
22002   if (!arg1) {
22003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22004     return 0;
22005   }
22006   arg2 = (std::type_info *)jarg2;
22007   if (!arg2) {
22008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22009     return 0;
22010   }
22011   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22012   {
22013     try {
22014       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22015     } catch (std::out_of_range& e) {
22016       {
22017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22018       };
22019     } catch (std::exception& e) {
22020       {
22021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (Dali::DaliException e) {
22024       {
22025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22026       };
22027     } catch (...) {
22028       {
22029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22030       };
22031     }
22032   }
22033
22034   jresult = (void *)result;
22035   return jresult;
22036 }
22037
22038
22039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22040   void * jresult ;
22041   std::type_info *arg1 = 0 ;
22042   std::type_info *arg2 = 0 ;
22043   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22044   bool arg4 ;
22045   Dali::TypeRegistration *result = 0 ;
22046
22047   arg1 = (std::type_info *)jarg1;
22048   if (!arg1) {
22049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22050     return 0;
22051   }
22052   arg2 = (std::type_info *)jarg2;
22053   if (!arg2) {
22054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22055     return 0;
22056   }
22057   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22058   arg4 = jarg4 ? true : false;
22059   {
22060     try {
22061       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22062     } catch (std::out_of_range& e) {
22063       {
22064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22065       };
22066     } catch (std::exception& e) {
22067       {
22068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22069       };
22070     } catch (Dali::DaliException e) {
22071       {
22072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22073       };
22074     } catch (...) {
22075       {
22076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22077       };
22078     }
22079   }
22080
22081   jresult = (void *)result;
22082   return jresult;
22083 }
22084
22085
22086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22087   void * jresult ;
22088   std::string *arg1 = 0 ;
22089   std::type_info *arg2 = 0 ;
22090   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22091   Dali::TypeRegistration *result = 0 ;
22092
22093   if (!jarg1) {
22094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22095     return 0;
22096   }
22097   std::string arg1_str(jarg1);
22098   arg1 = &arg1_str;
22099   arg2 = (std::type_info *)jarg2;
22100   if (!arg2) {
22101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22102     return 0;
22103   }
22104   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22105   {
22106     try {
22107       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22108     } catch (std::out_of_range& e) {
22109       {
22110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22111       };
22112     } catch (std::exception& e) {
22113       {
22114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22115       };
22116     } catch (Dali::DaliException e) {
22117       {
22118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22119       };
22120     } catch (...) {
22121       {
22122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22123       };
22124     }
22125   }
22126
22127   jresult = (void *)result;
22128
22129   //argout typemap for const std::string&
22130
22131   return jresult;
22132 }
22133
22134
22135 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22136   char * jresult ;
22137   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22138   std::string result;
22139
22140   arg1 = (Dali::TypeRegistration *)jarg1;
22141   {
22142     try {
22143       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22144     } catch (std::out_of_range& e) {
22145       {
22146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22147       };
22148     } catch (std::exception& e) {
22149       {
22150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22151       };
22152     } catch (Dali::DaliException e) {
22153       {
22154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22155       };
22156     } catch (...) {
22157       {
22158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22159       };
22160     }
22161   }
22162
22163   jresult = SWIG_csharp_string_callback((&result)->c_str());
22164   return jresult;
22165 }
22166
22167
22168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22169   std::string *arg1 = 0 ;
22170   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22171
22172   if (!jarg1) {
22173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22174     return ;
22175   }
22176   std::string arg1_str(jarg1);
22177   arg1 = &arg1_str;
22178   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22179   {
22180     try {
22181       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22182     } catch (std::out_of_range& e) {
22183       {
22184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22185       };
22186     } catch (std::exception& e) {
22187       {
22188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22189       };
22190     } catch (Dali::DaliException e) {
22191       {
22192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22193       };
22194     } catch (...) {
22195       {
22196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22197       };
22198     }
22199   }
22200
22201
22202   //argout typemap for const std::string&
22203
22204 }
22205
22206
22207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22208   std::string *arg1 = 0 ;
22209   std::string *arg2 = 0 ;
22210   int arg3 ;
22211   Dali::Property::Type arg4 ;
22212   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22213   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22214
22215   if (!jarg1) {
22216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22217     return ;
22218   }
22219   std::string arg1_str(jarg1);
22220   arg1 = &arg1_str;
22221   if (!jarg2) {
22222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22223     return ;
22224   }
22225   std::string arg2_str(jarg2);
22226   arg2 = &arg2_str;
22227   arg3 = (int)jarg3;
22228   arg4 = (Dali::Property::Type)jarg4;
22229   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22230   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22231   {
22232     try {
22233       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22234     } catch (std::out_of_range& e) {
22235       {
22236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22237       };
22238     } catch (std::exception& e) {
22239       {
22240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22241       };
22242     } catch (Dali::DaliException e) {
22243       {
22244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22245       };
22246     } catch (...) {
22247       {
22248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22249       };
22250     }
22251   }
22252
22253
22254   //argout typemap for const std::string&
22255
22256
22257   //argout typemap for const std::string&
22258
22259 }
22260
22261
22262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22263   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22264
22265   arg1 = (Dali::TypeRegistration *)jarg1;
22266   {
22267     try {
22268       delete arg1;
22269     } catch (std::out_of_range& e) {
22270       {
22271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22272       };
22273     } catch (std::exception& e) {
22274       {
22275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22276       };
22277     } catch (Dali::DaliException e) {
22278       {
22279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22280       };
22281     } catch (...) {
22282       {
22283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22284       };
22285     }
22286   }
22287
22288 }
22289
22290
22291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22292   void * jresult ;
22293   Dali::TypeRegistration *arg1 = 0 ;
22294   std::string *arg2 = 0 ;
22295   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22296   Dali::SignalConnectorType *result = 0 ;
22297
22298   arg1 = (Dali::TypeRegistration *)jarg1;
22299   if (!arg1) {
22300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22301     return 0;
22302   }
22303   if (!jarg2) {
22304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22305     return 0;
22306   }
22307   std::string arg2_str(jarg2);
22308   arg2 = &arg2_str;
22309   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22310   {
22311     try {
22312       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22313     } catch (std::out_of_range& e) {
22314       {
22315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22316       };
22317     } catch (std::exception& e) {
22318       {
22319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22320       };
22321     } catch (Dali::DaliException e) {
22322       {
22323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22324       };
22325     } catch (...) {
22326       {
22327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22328       };
22329     }
22330   }
22331
22332   jresult = (void *)result;
22333
22334   //argout typemap for const std::string&
22335
22336   return jresult;
22337 }
22338
22339
22340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22341   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22342
22343   arg1 = (Dali::SignalConnectorType *)jarg1;
22344   {
22345     try {
22346       delete arg1;
22347     } catch (std::out_of_range& e) {
22348       {
22349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22350       };
22351     } catch (std::exception& e) {
22352       {
22353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22354       };
22355     } catch (Dali::DaliException e) {
22356       {
22357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22358       };
22359     } catch (...) {
22360       {
22361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22362       };
22363     }
22364   }
22365
22366 }
22367
22368
22369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22370   void * jresult ;
22371   Dali::TypeRegistration *arg1 = 0 ;
22372   std::string *arg2 = 0 ;
22373   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22374   Dali::TypeAction *result = 0 ;
22375
22376   arg1 = (Dali::TypeRegistration *)jarg1;
22377   if (!arg1) {
22378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22379     return 0;
22380   }
22381   if (!jarg2) {
22382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22383     return 0;
22384   }
22385   std::string arg2_str(jarg2);
22386   arg2 = &arg2_str;
22387   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22388   {
22389     try {
22390       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22391     } catch (std::out_of_range& e) {
22392       {
22393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22394       };
22395     } catch (std::exception& e) {
22396       {
22397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22398       };
22399     } catch (Dali::DaliException e) {
22400       {
22401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22402       };
22403     } catch (...) {
22404       {
22405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22406       };
22407     }
22408   }
22409
22410   jresult = (void *)result;
22411
22412   //argout typemap for const std::string&
22413
22414   return jresult;
22415 }
22416
22417
22418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22419   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22420
22421   arg1 = (Dali::TypeAction *)jarg1;
22422   {
22423     try {
22424       delete arg1;
22425     } catch (std::out_of_range& e) {
22426       {
22427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22428       };
22429     } catch (std::exception& e) {
22430       {
22431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22432       };
22433     } catch (Dali::DaliException e) {
22434       {
22435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22436       };
22437     } catch (...) {
22438       {
22439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22440       };
22441     }
22442   }
22443
22444 }
22445
22446
22447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22448   void * jresult ;
22449   Dali::TypeRegistration *arg1 = 0 ;
22450   std::string *arg2 = 0 ;
22451   Dali::Property::Index arg3 ;
22452   Dali::Property::Type arg4 ;
22453   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22454   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22455   Dali::PropertyRegistration *result = 0 ;
22456
22457   arg1 = (Dali::TypeRegistration *)jarg1;
22458   if (!arg1) {
22459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22460     return 0;
22461   }
22462   if (!jarg2) {
22463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22464     return 0;
22465   }
22466   std::string arg2_str(jarg2);
22467   arg2 = &arg2_str;
22468   arg3 = (Dali::Property::Index)jarg3;
22469   arg4 = (Dali::Property::Type)jarg4;
22470   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22471   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22472   {
22473     try {
22474       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22475     } catch (std::out_of_range& e) {
22476       {
22477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22478       };
22479     } catch (std::exception& e) {
22480       {
22481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22482       };
22483     } catch (Dali::DaliException e) {
22484       {
22485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22486       };
22487     } catch (...) {
22488       {
22489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22490       };
22491     }
22492   }
22493
22494   jresult = (void *)result;
22495
22496   //argout typemap for const std::string&
22497
22498   return jresult;
22499 }
22500
22501
22502 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22503   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22504
22505   arg1 = (Dali::PropertyRegistration *)jarg1;
22506   {
22507     try {
22508       delete arg1;
22509     } catch (std::out_of_range& e) {
22510       {
22511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22512       };
22513     } catch (std::exception& e) {
22514       {
22515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22516       };
22517     } catch (Dali::DaliException e) {
22518       {
22519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22520       };
22521     } catch (...) {
22522       {
22523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22524       };
22525     }
22526   }
22527
22528 }
22529
22530
22531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22532   void * jresult ;
22533   Dali::TypeRegistration *arg1 = 0 ;
22534   std::string *arg2 = 0 ;
22535   Dali::Property::Index arg3 ;
22536   Dali::Property::Type arg4 ;
22537   Dali::AnimatablePropertyRegistration *result = 0 ;
22538
22539   arg1 = (Dali::TypeRegistration *)jarg1;
22540   if (!arg1) {
22541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22542     return 0;
22543   }
22544   if (!jarg2) {
22545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22546     return 0;
22547   }
22548   std::string arg2_str(jarg2);
22549   arg2 = &arg2_str;
22550   arg3 = (Dali::Property::Index)jarg3;
22551   arg4 = (Dali::Property::Type)jarg4;
22552   {
22553     try {
22554       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22555     } catch (std::out_of_range& e) {
22556       {
22557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22558       };
22559     } catch (std::exception& e) {
22560       {
22561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22562       };
22563     } catch (Dali::DaliException e) {
22564       {
22565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22566       };
22567     } catch (...) {
22568       {
22569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22570       };
22571     }
22572   }
22573
22574   jresult = (void *)result;
22575
22576   //argout typemap for const std::string&
22577
22578   return jresult;
22579 }
22580
22581
22582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22583   void * jresult ;
22584   Dali::TypeRegistration *arg1 = 0 ;
22585   std::string *arg2 = 0 ;
22586   Dali::Property::Index arg3 ;
22587   Dali::Property::Value *arg4 = 0 ;
22588   Dali::AnimatablePropertyRegistration *result = 0 ;
22589
22590   arg1 = (Dali::TypeRegistration *)jarg1;
22591   if (!arg1) {
22592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22593     return 0;
22594   }
22595   if (!jarg2) {
22596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22597     return 0;
22598   }
22599   std::string arg2_str(jarg2);
22600   arg2 = &arg2_str;
22601   arg3 = (Dali::Property::Index)jarg3;
22602   arg4 = (Dali::Property::Value *)jarg4;
22603   if (!arg4) {
22604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22605     return 0;
22606   }
22607   {
22608     try {
22609       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22610     } catch (std::out_of_range& e) {
22611       {
22612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22613       };
22614     } catch (std::exception& e) {
22615       {
22616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22617       };
22618     } catch (Dali::DaliException e) {
22619       {
22620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22621       };
22622     } catch (...) {
22623       {
22624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22625       };
22626     }
22627   }
22628
22629   jresult = (void *)result;
22630
22631   //argout typemap for const std::string&
22632
22633   return jresult;
22634 }
22635
22636
22637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22638   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22639
22640   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22641   {
22642     try {
22643       delete arg1;
22644     } catch (std::out_of_range& e) {
22645       {
22646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22647       };
22648     } catch (std::exception& e) {
22649       {
22650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22651       };
22652     } catch (Dali::DaliException e) {
22653       {
22654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22655       };
22656     } catch (...) {
22657       {
22658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22659       };
22660     }
22661   }
22662
22663 }
22664
22665
22666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22667   void * jresult ;
22668   Dali::TypeRegistration *arg1 = 0 ;
22669   std::string *arg2 = 0 ;
22670   Dali::Property::Index arg3 ;
22671   Dali::Property::Index arg4 ;
22672   unsigned int arg5 ;
22673   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22674
22675   arg1 = (Dali::TypeRegistration *)jarg1;
22676   if (!arg1) {
22677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22678     return 0;
22679   }
22680   if (!jarg2) {
22681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22682     return 0;
22683   }
22684   std::string arg2_str(jarg2);
22685   arg2 = &arg2_str;
22686   arg3 = (Dali::Property::Index)jarg3;
22687   arg4 = (Dali::Property::Index)jarg4;
22688   arg5 = (unsigned int)jarg5;
22689   {
22690     try {
22691       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22692     } catch (std::out_of_range& e) {
22693       {
22694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22695       };
22696     } catch (std::exception& e) {
22697       {
22698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22699       };
22700     } catch (Dali::DaliException e) {
22701       {
22702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22703       };
22704     } catch (...) {
22705       {
22706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22707       };
22708     }
22709   }
22710
22711   jresult = (void *)result;
22712
22713   //argout typemap for const std::string&
22714
22715   return jresult;
22716 }
22717
22718
22719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22720   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22721
22722   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22723   {
22724     try {
22725       delete arg1;
22726     } catch (std::out_of_range& e) {
22727       {
22728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22729       };
22730     } catch (std::exception& e) {
22731       {
22732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22733       };
22734     } catch (Dali::DaliException e) {
22735       {
22736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22737       };
22738     } catch (...) {
22739       {
22740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22741       };
22742     }
22743   }
22744
22745 }
22746
22747
22748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22749   void * jresult ;
22750   Dali::TypeRegistration *arg1 = 0 ;
22751   std::string *arg2 = 0 ;
22752   Dali::Property::Index arg3 ;
22753   Dali::Property::Type arg4 ;
22754   Dali::ChildPropertyRegistration *result = 0 ;
22755
22756   arg1 = (Dali::TypeRegistration *)jarg1;
22757   if (!arg1) {
22758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22759     return 0;
22760   }
22761   if (!jarg2) {
22762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22763     return 0;
22764   }
22765   std::string arg2_str(jarg2);
22766   arg2 = &arg2_str;
22767   arg3 = (Dali::Property::Index)jarg3;
22768   arg4 = (Dali::Property::Type)jarg4;
22769   {
22770     try {
22771       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22772     } catch (std::out_of_range& e) {
22773       {
22774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22775       };
22776     } catch (std::exception& e) {
22777       {
22778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22779       };
22780     } catch (Dali::DaliException e) {
22781       {
22782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22783       };
22784     } catch (...) {
22785       {
22786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22787       };
22788     }
22789   }
22790
22791   jresult = (void *)result;
22792
22793   //argout typemap for const std::string&
22794
22795   return jresult;
22796 }
22797
22798
22799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22800   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22801
22802   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22803   {
22804     try {
22805       delete arg1;
22806     } catch (std::out_of_range& e) {
22807       {
22808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22809       };
22810     } catch (std::exception& e) {
22811       {
22812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22813       };
22814     } catch (Dali::DaliException e) {
22815       {
22816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22817       };
22818     } catch (...) {
22819       {
22820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22821       };
22822     }
22823   }
22824
22825 }
22826
22827
22828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22829   unsigned int jresult ;
22830   std::string *arg1 = 0 ;
22831   std::type_info *arg2 = 0 ;
22832   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22833   bool result;
22834
22835   if (!jarg1) {
22836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22837     return 0;
22838   }
22839   std::string arg1_str(jarg1);
22840   arg1 = &arg1_str;
22841   arg2 = (std::type_info *)jarg2;
22842   if (!arg2) {
22843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22844     return 0;
22845   }
22846   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22847   {
22848     try {
22849       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22850     } catch (std::out_of_range& e) {
22851       {
22852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22853       };
22854     } catch (std::exception& e) {
22855       {
22856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22857       };
22858     } catch (Dali::DaliException e) {
22859       {
22860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22861       };
22862     } catch (...) {
22863       {
22864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22865       };
22866     }
22867   }
22868
22869   jresult = result;
22870
22871   //argout typemap for const std::string&
22872
22873   return jresult;
22874 }
22875
22876
22877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22878   unsigned int jresult ;
22879   std::string *arg1 = 0 ;
22880   std::string *arg2 = 0 ;
22881   Dali::Property::Index arg3 ;
22882   Dali::Property::Type arg4 ;
22883   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22884   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22885   bool result;
22886
22887   if (!jarg1) {
22888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22889     return 0;
22890   }
22891   std::string arg1_str(jarg1);
22892   arg1 = &arg1_str;
22893   if (!jarg2) {
22894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22895     return 0;
22896   }
22897   std::string arg2_str(jarg2);
22898   arg2 = &arg2_str;
22899   arg3 = (Dali::Property::Index)jarg3;
22900   arg4 = (Dali::Property::Type)jarg4;
22901   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22902   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22903   {
22904     try {
22905       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22906     } catch (std::out_of_range& e) {
22907       {
22908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22909       };
22910     } catch (std::exception& e) {
22911       {
22912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22913       };
22914     } catch (Dali::DaliException e) {
22915       {
22916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22917       };
22918     } catch (...) {
22919       {
22920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22921       };
22922     }
22923   }
22924
22925   jresult = result;
22926
22927   //argout typemap for const std::string&
22928
22929
22930   //argout typemap for const std::string&
22931
22932   return jresult;
22933 }
22934
22935
22936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22937   float jresult ;
22938   float result;
22939
22940   result = (float)(float)Dali::ParentOrigin::TOP;
22941   jresult = result;
22942   return jresult;
22943 }
22944
22945
22946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22947   float jresult ;
22948   float result;
22949
22950   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22951   jresult = result;
22952   return jresult;
22953 }
22954
22955
22956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22957   float jresult ;
22958   float result;
22959
22960   result = (float)(float)Dali::ParentOrigin::LEFT;
22961   jresult = result;
22962   return jresult;
22963 }
22964
22965
22966 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22967   float jresult ;
22968   float result;
22969
22970   result = (float)(float)Dali::ParentOrigin::RIGHT;
22971   jresult = result;
22972   return jresult;
22973 }
22974
22975
22976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22977   float jresult ;
22978   float result;
22979
22980   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22981   jresult = result;
22982   return jresult;
22983 }
22984
22985
22986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22987   void * jresult ;
22988   Dali::Vector3 *result = 0 ;
22989
22990   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22991   jresult = (void *)result;
22992   return jresult;
22993 }
22994
22995
22996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22997   void * jresult ;
22998   Dali::Vector3 *result = 0 ;
22999
23000   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23001   jresult = (void *)result;
23002   return jresult;
23003 }
23004
23005
23006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23007   void * jresult ;
23008   Dali::Vector3 *result = 0 ;
23009
23010   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23011   jresult = (void *)result;
23012   return jresult;
23013 }
23014
23015
23016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23017   void * jresult ;
23018   Dali::Vector3 *result = 0 ;
23019
23020   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23021   jresult = (void *)result;
23022   return jresult;
23023 }
23024
23025
23026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23027   void * jresult ;
23028   Dali::Vector3 *result = 0 ;
23029
23030   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23031   jresult = (void *)result;
23032   return jresult;
23033 }
23034
23035
23036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23037   void * jresult ;
23038   Dali::Vector3 *result = 0 ;
23039
23040   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23041   jresult = (void *)result;
23042   return jresult;
23043 }
23044
23045
23046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23047   void * jresult ;
23048   Dali::Vector3 *result = 0 ;
23049
23050   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23051   jresult = (void *)result;
23052   return jresult;
23053 }
23054
23055
23056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23057   void * jresult ;
23058   Dali::Vector3 *result = 0 ;
23059
23060   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23061   jresult = (void *)result;
23062   return jresult;
23063 }
23064
23065
23066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23067   void * jresult ;
23068   Dali::Vector3 *result = 0 ;
23069
23070   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23071   jresult = (void *)result;
23072   return jresult;
23073 }
23074
23075
23076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23077   float jresult ;
23078   float result;
23079
23080   result = (float)(float)Dali::AnchorPoint::TOP;
23081   jresult = result;
23082   return jresult;
23083 }
23084
23085
23086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23087   float jresult ;
23088   float result;
23089
23090   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23091   jresult = result;
23092   return jresult;
23093 }
23094
23095
23096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23097   float jresult ;
23098   float result;
23099
23100   result = (float)(float)Dali::AnchorPoint::LEFT;
23101   jresult = result;
23102   return jresult;
23103 }
23104
23105
23106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23107   float jresult ;
23108   float result;
23109
23110   result = (float)(float)Dali::AnchorPoint::RIGHT;
23111   jresult = result;
23112   return jresult;
23113 }
23114
23115
23116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23117   float jresult ;
23118   float result;
23119
23120   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23121   jresult = result;
23122   return jresult;
23123 }
23124
23125
23126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23127   void * jresult ;
23128   Dali::Vector3 *result = 0 ;
23129
23130   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23131   jresult = (void *)result;
23132   return jresult;
23133 }
23134
23135
23136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23137   void * jresult ;
23138   Dali::Vector3 *result = 0 ;
23139
23140   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23141   jresult = (void *)result;
23142   return jresult;
23143 }
23144
23145
23146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23147   void * jresult ;
23148   Dali::Vector3 *result = 0 ;
23149
23150   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23151   jresult = (void *)result;
23152   return jresult;
23153 }
23154
23155
23156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23157   void * jresult ;
23158   Dali::Vector3 *result = 0 ;
23159
23160   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23161   jresult = (void *)result;
23162   return jresult;
23163 }
23164
23165
23166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23167   void * jresult ;
23168   Dali::Vector3 *result = 0 ;
23169
23170   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23171   jresult = (void *)result;
23172   return jresult;
23173 }
23174
23175
23176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23177   void * jresult ;
23178   Dali::Vector3 *result = 0 ;
23179
23180   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23181   jresult = (void *)result;
23182   return jresult;
23183 }
23184
23185
23186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23187   void * jresult ;
23188   Dali::Vector3 *result = 0 ;
23189
23190   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23191   jresult = (void *)result;
23192   return jresult;
23193 }
23194
23195
23196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23197   void * jresult ;
23198   Dali::Vector3 *result = 0 ;
23199
23200   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23201   jresult = (void *)result;
23202   return jresult;
23203 }
23204
23205
23206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23207   void * jresult ;
23208   Dali::Vector3 *result = 0 ;
23209
23210   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23211   jresult = (void *)result;
23212   return jresult;
23213 }
23214
23215
23216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23217   void * jresult ;
23218   Dali::Vector4 *result = 0 ;
23219
23220   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23221   jresult = (void *)result;
23222   return jresult;
23223 }
23224
23225
23226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23227   void * jresult ;
23228   Dali::Vector4 *result = 0 ;
23229
23230   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23231   jresult = (void *)result;
23232   return jresult;
23233 }
23234
23235
23236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23237   void * jresult ;
23238   Dali::Vector4 *result = 0 ;
23239
23240   result = (Dali::Vector4 *)&Dali::Color::RED;
23241   jresult = (void *)result;
23242   return jresult;
23243 }
23244
23245
23246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23247   void * jresult ;
23248   Dali::Vector4 *result = 0 ;
23249
23250   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23251   jresult = (void *)result;
23252   return jresult;
23253 }
23254
23255
23256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23257   void * jresult ;
23258   Dali::Vector4 *result = 0 ;
23259
23260   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23261   jresult = (void *)result;
23262   return jresult;
23263 }
23264
23265
23266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23267   void * jresult ;
23268   Dali::Vector4 *result = 0 ;
23269
23270   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23271   jresult = (void *)result;
23272   return jresult;
23273 }
23274
23275
23276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23277   void * jresult ;
23278   Dali::Vector4 *result = 0 ;
23279
23280   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23281   jresult = (void *)result;
23282   return jresult;
23283 }
23284
23285
23286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23287   void * jresult ;
23288   Dali::Vector4 *result = 0 ;
23289
23290   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23291   jresult = (void *)result;
23292   return jresult;
23293 }
23294
23295
23296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23297   void * jresult ;
23298   Dali::Vector4 *result = 0 ;
23299
23300   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23301   jresult = (void *)result;
23302   return jresult;
23303 }
23304
23305
23306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23307   float jresult ;
23308   float result;
23309
23310   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23311   jresult = result;
23312   return jresult;
23313 }
23314
23315
23316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23317   float jresult ;
23318   float result;
23319
23320   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23321   jresult = result;
23322   return jresult;
23323 }
23324
23325
23326 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23327   float jresult ;
23328   float result;
23329
23330   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23331   jresult = result;
23332   return jresult;
23333 }
23334
23335
23336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23337   float jresult ;
23338   float result;
23339
23340   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23341   jresult = result;
23342   return jresult;
23343 }
23344
23345
23346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23347   float jresult ;
23348   float result;
23349
23350   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23351   jresult = result;
23352   return jresult;
23353 }
23354
23355
23356 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23357   float jresult ;
23358   float result;
23359
23360   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23361   jresult = result;
23362   return jresult;
23363 }
23364
23365
23366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23367   float jresult ;
23368   float result;
23369
23370   result = (float)(float)Dali::Math::PI;
23371   jresult = result;
23372   return jresult;
23373 }
23374
23375
23376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23377   float jresult ;
23378   float result;
23379
23380   result = (float)(float)Dali::Math::PI_2;
23381   jresult = result;
23382   return jresult;
23383 }
23384
23385
23386 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23387   float jresult ;
23388   float result;
23389
23390   result = (float)(float)Dali::Math::PI_4;
23391   jresult = result;
23392   return jresult;
23393 }
23394
23395
23396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23397   float jresult ;
23398   float result;
23399
23400   result = (float)(float)Dali::Math::PI_OVER_180;
23401   jresult = result;
23402   return jresult;
23403 }
23404
23405
23406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23407   float jresult ;
23408   float result;
23409
23410   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23411   jresult = result;
23412   return jresult;
23413 }
23414
23415
23416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23417   int jresult ;
23418   Dali::ResizePolicy::Type result;
23419
23420   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23421   jresult = (int)result;
23422   return jresult;
23423 }
23424
23425
23426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23427   unsigned long jresult ;
23428   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23429   Dali::VectorBase::SizeType result;
23430
23431   arg1 = (Dali::VectorBase *)jarg1;
23432   {
23433     try {
23434       result = ((Dali::VectorBase const *)arg1)->Count();
23435     } catch (std::out_of_range& e) {
23436       {
23437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23438       };
23439     } catch (std::exception& e) {
23440       {
23441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23442       };
23443     } catch (Dali::DaliException e) {
23444       {
23445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23446       };
23447     } catch (...) {
23448       {
23449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23450       };
23451     }
23452   }
23453
23454   jresult = (unsigned long)result;
23455   return jresult;
23456 }
23457
23458
23459 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23460   unsigned long jresult ;
23461   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23462   Dali::VectorBase::SizeType result;
23463
23464   arg1 = (Dali::VectorBase *)jarg1;
23465   {
23466     try {
23467       result = ((Dali::VectorBase const *)arg1)->Size();
23468     } catch (std::out_of_range& e) {
23469       {
23470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23471       };
23472     } catch (std::exception& e) {
23473       {
23474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23475       };
23476     } catch (Dali::DaliException e) {
23477       {
23478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23479       };
23480     } catch (...) {
23481       {
23482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23483       };
23484     }
23485   }
23486
23487   jresult = (unsigned long)result;
23488   return jresult;
23489 }
23490
23491
23492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23493   unsigned int jresult ;
23494   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23495   bool result;
23496
23497   arg1 = (Dali::VectorBase *)jarg1;
23498   {
23499     try {
23500       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23501     } catch (std::out_of_range& e) {
23502       {
23503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23504       };
23505     } catch (std::exception& e) {
23506       {
23507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23508       };
23509     } catch (Dali::DaliException e) {
23510       {
23511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23512       };
23513     } catch (...) {
23514       {
23515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23516       };
23517     }
23518   }
23519
23520   jresult = result;
23521   return jresult;
23522 }
23523
23524
23525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23526   unsigned long jresult ;
23527   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23528   Dali::VectorBase::SizeType result;
23529
23530   arg1 = (Dali::VectorBase *)jarg1;
23531   {
23532     try {
23533       result = ((Dali::VectorBase const *)arg1)->Capacity();
23534     } catch (std::out_of_range& e) {
23535       {
23536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23537       };
23538     } catch (std::exception& e) {
23539       {
23540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23541       };
23542     } catch (Dali::DaliException e) {
23543       {
23544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23545       };
23546     } catch (...) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23549       };
23550     }
23551   }
23552
23553   jresult = (unsigned long)result;
23554   return jresult;
23555 }
23556
23557
23558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23559   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23560
23561   arg1 = (Dali::VectorBase *)jarg1;
23562   {
23563     try {
23564       (arg1)->Release();
23565     } catch (std::out_of_range& e) {
23566       {
23567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23568       };
23569     } catch (std::exception& e) {
23570       {
23571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23572       };
23573     } catch (Dali::DaliException e) {
23574       {
23575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23576       };
23577     } catch (...) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23580       };
23581     }
23582   }
23583
23584 }
23585
23586
23587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23588   void * jresult ;
23589   Dali::Image *result = 0 ;
23590
23591   {
23592     try {
23593       result = (Dali::Image *)new Dali::Image();
23594     } catch (std::out_of_range& e) {
23595       {
23596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23597       };
23598     } catch (std::exception& e) {
23599       {
23600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23601       };
23602     } catch (Dali::DaliException e) {
23603       {
23604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23605       };
23606     } catch (...) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23609       };
23610     }
23611   }
23612
23613   jresult = (void *)result;
23614   return jresult;
23615 }
23616
23617
23618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23619   Dali::Image *arg1 = (Dali::Image *) 0 ;
23620
23621   arg1 = (Dali::Image *)jarg1;
23622   {
23623     try {
23624       delete arg1;
23625     } catch (std::out_of_range& e) {
23626       {
23627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23628       };
23629     } catch (std::exception& e) {
23630       {
23631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23632       };
23633     } catch (Dali::DaliException e) {
23634       {
23635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23636       };
23637     } catch (...) {
23638       {
23639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23640       };
23641     }
23642   }
23643
23644 }
23645
23646
23647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23648   void * jresult ;
23649   Dali::Image *arg1 = 0 ;
23650   Dali::Image *result = 0 ;
23651
23652   arg1 = (Dali::Image *)jarg1;
23653   if (!arg1) {
23654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23655     return 0;
23656   }
23657   {
23658     try {
23659       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23660     } catch (std::out_of_range& e) {
23661       {
23662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23663       };
23664     } catch (std::exception& e) {
23665       {
23666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23667       };
23668     } catch (Dali::DaliException e) {
23669       {
23670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23671       };
23672     } catch (...) {
23673       {
23674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23675       };
23676     }
23677   }
23678
23679   jresult = (void *)result;
23680   return jresult;
23681 }
23682
23683
23684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23685   void * jresult ;
23686   Dali::Image *arg1 = (Dali::Image *) 0 ;
23687   Dali::Image *arg2 = 0 ;
23688   Dali::Image *result = 0 ;
23689
23690   arg1 = (Dali::Image *)jarg1;
23691   arg2 = (Dali::Image *)jarg2;
23692   if (!arg2) {
23693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23694     return 0;
23695   }
23696   {
23697     try {
23698       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23699     } catch (std::out_of_range& e) {
23700       {
23701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23702       };
23703     } catch (std::exception& e) {
23704       {
23705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23706       };
23707     } catch (Dali::DaliException e) {
23708       {
23709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23710       };
23711     } catch (...) {
23712       {
23713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23714       };
23715     }
23716   }
23717
23718   jresult = (void *)result;
23719   return jresult;
23720 }
23721
23722
23723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23724   void * jresult ;
23725   Dali::BaseHandle arg1 ;
23726   Dali::BaseHandle *argp1 ;
23727   Dali::Image result;
23728
23729   argp1 = (Dali::BaseHandle *)jarg1;
23730   if (!argp1) {
23731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23732     return 0;
23733   }
23734   arg1 = *argp1;
23735   {
23736     try {
23737       result = Dali::Image::DownCast(arg1);
23738     } catch (std::out_of_range& e) {
23739       {
23740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23741       };
23742     } catch (std::exception& e) {
23743       {
23744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (Dali::DaliException e) {
23747       {
23748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23749       };
23750     } catch (...) {
23751       {
23752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23753       };
23754     }
23755   }
23756
23757   jresult = new Dali::Image((const Dali::Image &)result);
23758   return jresult;
23759 }
23760
23761
23762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23763   unsigned int jresult ;
23764   Dali::Image *arg1 = (Dali::Image *) 0 ;
23765   unsigned int result;
23766
23767   arg1 = (Dali::Image *)jarg1;
23768   {
23769     try {
23770       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23771     } catch (std::out_of_range& e) {
23772       {
23773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23774       };
23775     } catch (std::exception& e) {
23776       {
23777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (Dali::DaliException e) {
23780       {
23781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23782       };
23783     } catch (...) {
23784       {
23785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23786       };
23787     }
23788   }
23789
23790   jresult = result;
23791   return jresult;
23792 }
23793
23794
23795 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23796   unsigned int jresult ;
23797   Dali::Image *arg1 = (Dali::Image *) 0 ;
23798   unsigned int result;
23799
23800   arg1 = (Dali::Image *)jarg1;
23801   {
23802     try {
23803       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23804     } catch (std::out_of_range& e) {
23805       {
23806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23807       };
23808     } catch (std::exception& e) {
23809       {
23810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23811       };
23812     } catch (Dali::DaliException e) {
23813       {
23814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23815       };
23816     } catch (...) {
23817       {
23818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23819       };
23820     }
23821   }
23822
23823   jresult = result;
23824   return jresult;
23825 }
23826
23827
23828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23829   void * jresult ;
23830   Dali::Image *arg1 = (Dali::Image *) 0 ;
23831   Dali::Image::ImageSignalType *result = 0 ;
23832
23833   arg1 = (Dali::Image *)jarg1;
23834   {
23835     try {
23836       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23837     } catch (std::out_of_range& e) {
23838       {
23839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23840       };
23841     } catch (std::exception& e) {
23842       {
23843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23844       };
23845     } catch (Dali::DaliException e) {
23846       {
23847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23848       };
23849     } catch (...) {
23850       {
23851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23852       };
23853     }
23854   }
23855
23856   jresult = (void *)result;
23857   return jresult;
23858 }
23859
23860
23861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23862   int jresult ;
23863   Dali::Pixel::Format result;
23864
23865   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23866   jresult = (int)result;
23867   return jresult;
23868 }
23869
23870
23871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23872   int jresult ;
23873   Dali::Pixel::Format result;
23874
23875   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23876   jresult = (int)result;
23877   return jresult;
23878 }
23879
23880
23881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23882   unsigned int jresult ;
23883   Dali::Pixel::Format arg1 ;
23884   bool result;
23885
23886   arg1 = (Dali::Pixel::Format)jarg1;
23887   {
23888     try {
23889       result = (bool)Dali::Pixel::HasAlpha(arg1);
23890     } catch (std::out_of_range& e) {
23891       {
23892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23893       };
23894     } catch (std::exception& e) {
23895       {
23896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23897       };
23898     } catch (Dali::DaliException e) {
23899       {
23900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23901       };
23902     } catch (...) {
23903       {
23904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23905       };
23906     }
23907   }
23908
23909   jresult = result;
23910   return jresult;
23911 }
23912
23913
23914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23915   unsigned int jresult ;
23916   Dali::Pixel::Format arg1 ;
23917   unsigned int result;
23918
23919   arg1 = (Dali::Pixel::Format)jarg1;
23920   {
23921     try {
23922       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23923     } catch (std::out_of_range& e) {
23924       {
23925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23926       };
23927     } catch (std::exception& e) {
23928       {
23929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23930       };
23931     } catch (Dali::DaliException e) {
23932       {
23933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23934       };
23935     } catch (...) {
23936       {
23937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23938       };
23939     }
23940   }
23941
23942   jresult = result;
23943   return jresult;
23944 }
23945
23946
23947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23948   Dali::Pixel::Format arg1 ;
23949   int *arg2 = 0 ;
23950   int *arg3 = 0 ;
23951
23952   arg1 = (Dali::Pixel::Format)jarg1;
23953   arg2 = (int *)jarg2;
23954   if (!arg2) {
23955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23956     return ;
23957   }
23958   arg3 = (int *)jarg3;
23959   if (!arg3) {
23960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23961     return ;
23962   }
23963   {
23964     try {
23965       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23966     } catch (std::out_of_range& e) {
23967       {
23968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23969       };
23970     } catch (std::exception& e) {
23971       {
23972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23973       };
23974     } catch (Dali::DaliException e) {
23975       {
23976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23977       };
23978     } catch (...) {
23979       {
23980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23981       };
23982     }
23983   }
23984
23985 }
23986
23987
23988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23989   void * jresult ;
23990   unsigned char *arg1 = (unsigned char *) 0 ;
23991   unsigned int arg2 ;
23992   unsigned int arg3 ;
23993   unsigned int arg4 ;
23994   Dali::Pixel::Format arg5 ;
23995   Dali::PixelData::ReleaseFunction arg6 ;
23996   Dali::PixelData result;
23997
23998   arg1 = jarg1;
23999   arg2 = (unsigned int)jarg2;
24000   arg3 = (unsigned int)jarg3;
24001   arg4 = (unsigned int)jarg4;
24002   arg5 = (Dali::Pixel::Format)jarg5;
24003   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24004   {
24005     try {
24006       result = Dali::PixelData::New(arg1,arg2,arg3,arg4,arg5,arg6);
24007     } catch (std::out_of_range& e) {
24008       {
24009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24010       };
24011     } catch (std::exception& e) {
24012       {
24013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24014       };
24015     } catch (Dali::DaliException e) {
24016       {
24017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24018       };
24019     } catch (...) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24022       };
24023     }
24024   }
24025
24026   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24027
24028
24029   return jresult;
24030 }
24031
24032
24033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24034   void * jresult ;
24035   Dali::PixelData *result = 0 ;
24036
24037   {
24038     try {
24039       result = (Dali::PixelData *)new Dali::PixelData();
24040     } catch (std::out_of_range& e) {
24041       {
24042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24043       };
24044     } catch (std::exception& e) {
24045       {
24046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24047       };
24048     } catch (Dali::DaliException e) {
24049       {
24050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24051       };
24052     } catch (...) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24055       };
24056     }
24057   }
24058
24059   jresult = (void *)result;
24060   return jresult;
24061 }
24062
24063
24064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24065   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24066
24067   arg1 = (Dali::PixelData *)jarg1;
24068   {
24069     try {
24070       delete arg1;
24071     } catch (std::out_of_range& e) {
24072       {
24073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24074       };
24075     } catch (std::exception& e) {
24076       {
24077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24078       };
24079     } catch (Dali::DaliException e) {
24080       {
24081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24082       };
24083     } catch (...) {
24084       {
24085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24086       };
24087     }
24088   }
24089
24090 }
24091
24092
24093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24094   void * jresult ;
24095   Dali::PixelData *arg1 = 0 ;
24096   Dali::PixelData *result = 0 ;
24097
24098   arg1 = (Dali::PixelData *)jarg1;
24099   if (!arg1) {
24100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24101     return 0;
24102   }
24103   {
24104     try {
24105       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24106     } catch (std::out_of_range& e) {
24107       {
24108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24109       };
24110     } catch (std::exception& e) {
24111       {
24112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24113       };
24114     } catch (Dali::DaliException e) {
24115       {
24116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24117       };
24118     } catch (...) {
24119       {
24120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24121       };
24122     }
24123   }
24124
24125   jresult = (void *)result;
24126   return jresult;
24127 }
24128
24129
24130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24131   void * jresult ;
24132   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24133   Dali::PixelData *arg2 = 0 ;
24134   Dali::PixelData *result = 0 ;
24135
24136   arg1 = (Dali::PixelData *)jarg1;
24137   arg2 = (Dali::PixelData *)jarg2;
24138   if (!arg2) {
24139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24140     return 0;
24141   }
24142   {
24143     try {
24144       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24145     } catch (std::out_of_range& e) {
24146       {
24147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24148       };
24149     } catch (std::exception& e) {
24150       {
24151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24152       };
24153     } catch (Dali::DaliException e) {
24154       {
24155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24156       };
24157     } catch (...) {
24158       {
24159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24160       };
24161     }
24162   }
24163
24164   jresult = (void *)result;
24165   return jresult;
24166 }
24167
24168
24169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24170   unsigned int jresult ;
24171   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24172   unsigned int result;
24173
24174   arg1 = (Dali::PixelData *)jarg1;
24175   {
24176     try {
24177       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24178     } catch (std::out_of_range& e) {
24179       {
24180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24181       };
24182     } catch (std::exception& e) {
24183       {
24184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24185       };
24186     } catch (Dali::DaliException e) {
24187       {
24188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24189       };
24190     } catch (...) {
24191       {
24192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24193       };
24194     }
24195   }
24196
24197   jresult = result;
24198   return jresult;
24199 }
24200
24201
24202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24203   unsigned int jresult ;
24204   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24205   unsigned int result;
24206
24207   arg1 = (Dali::PixelData *)jarg1;
24208   {
24209     try {
24210       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24211     } catch (std::out_of_range& e) {
24212       {
24213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24214       };
24215     } catch (std::exception& e) {
24216       {
24217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24218       };
24219     } catch (Dali::DaliException e) {
24220       {
24221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24222       };
24223     } catch (...) {
24224       {
24225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24226       };
24227     }
24228   }
24229
24230   jresult = result;
24231   return jresult;
24232 }
24233
24234
24235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24236   int jresult ;
24237   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24238   Dali::Pixel::Format result;
24239
24240   arg1 = (Dali::PixelData *)jarg1;
24241   {
24242     try {
24243       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24244     } catch (std::out_of_range& e) {
24245       {
24246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24247       };
24248     } catch (std::exception& e) {
24249       {
24250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24251       };
24252     } catch (Dali::DaliException e) {
24253       {
24254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24255       };
24256     } catch (...) {
24257       {
24258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24259       };
24260     }
24261   }
24262
24263   jresult = (int)result;
24264   return jresult;
24265 }
24266
24267
24268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24269   unsigned int jresult ;
24270   unsigned int result;
24271
24272   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24273   jresult = result;
24274   return jresult;
24275 }
24276
24277
24278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24279   unsigned int jresult ;
24280   unsigned int result;
24281
24282   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24283   jresult = result;
24284   return jresult;
24285 }
24286
24287
24288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24289   unsigned int jresult ;
24290   unsigned int result;
24291
24292   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24293   jresult = result;
24294   return jresult;
24295 }
24296
24297
24298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24299   unsigned int jresult ;
24300   unsigned int result;
24301
24302   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24303   jresult = result;
24304   return jresult;
24305 }
24306
24307
24308 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24309   unsigned int jresult ;
24310   unsigned int result;
24311
24312   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24313   jresult = result;
24314   return jresult;
24315 }
24316
24317
24318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24319   unsigned int jresult ;
24320   unsigned int result;
24321
24322   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24323   jresult = result;
24324   return jresult;
24325 }
24326
24327
24328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24329   void * jresult ;
24330   Dali::TextureType::Type arg1 ;
24331   Dali::Pixel::Format arg2 ;
24332   unsigned int arg3 ;
24333   unsigned int arg4 ;
24334   Dali::Texture result;
24335
24336   arg1 = (Dali::TextureType::Type)jarg1;
24337   arg2 = (Dali::Pixel::Format)jarg2;
24338   arg3 = (unsigned int)jarg3;
24339   arg4 = (unsigned int)jarg4;
24340   {
24341     try {
24342       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24343     } catch (std::out_of_range& e) {
24344       {
24345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24346       };
24347     } catch (std::exception& e) {
24348       {
24349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24350       };
24351     } catch (Dali::DaliException e) {
24352       {
24353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24354       };
24355     } catch (...) {
24356       {
24357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24358       };
24359     }
24360   }
24361
24362   jresult = new Dali::Texture((const Dali::Texture &)result);
24363   return jresult;
24364 }
24365
24366
24367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24368   void * jresult ;
24369   NativeImageInterface *arg1 = 0 ;
24370   Dali::Texture result;
24371
24372   arg1 = (NativeImageInterface *)jarg1;
24373   if (!arg1) {
24374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24375     return 0;
24376   }
24377   {
24378     try {
24379       result = Dali::Texture::New(*arg1);
24380     } catch (std::out_of_range& e) {
24381       {
24382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24383       };
24384     } catch (std::exception& e) {
24385       {
24386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (Dali::DaliException e) {
24389       {
24390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24391       };
24392     } catch (...) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24395       };
24396     }
24397   }
24398
24399   jresult = new Dali::Texture((const Dali::Texture &)result);
24400   return jresult;
24401 }
24402
24403
24404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24405   void * jresult ;
24406   Dali::Texture *result = 0 ;
24407
24408   {
24409     try {
24410       result = (Dali::Texture *)new Dali::Texture();
24411     } catch (std::out_of_range& e) {
24412       {
24413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24414       };
24415     } catch (std::exception& e) {
24416       {
24417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24418       };
24419     } catch (Dali::DaliException e) {
24420       {
24421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24422       };
24423     } catch (...) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24426       };
24427     }
24428   }
24429
24430   jresult = (void *)result;
24431   return jresult;
24432 }
24433
24434
24435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24436   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24437
24438   arg1 = (Dali::Texture *)jarg1;
24439   {
24440     try {
24441       delete arg1;
24442     } catch (std::out_of_range& e) {
24443       {
24444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24445       };
24446     } catch (std::exception& e) {
24447       {
24448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24449       };
24450     } catch (Dali::DaliException e) {
24451       {
24452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24453       };
24454     } catch (...) {
24455       {
24456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24457       };
24458     }
24459   }
24460
24461 }
24462
24463
24464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24465   void * jresult ;
24466   Dali::Texture *arg1 = 0 ;
24467   Dali::Texture *result = 0 ;
24468
24469   arg1 = (Dali::Texture *)jarg1;
24470   if (!arg1) {
24471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24472     return 0;
24473   }
24474   {
24475     try {
24476       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24477     } catch (std::out_of_range& e) {
24478       {
24479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24480       };
24481     } catch (std::exception& e) {
24482       {
24483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24484       };
24485     } catch (Dali::DaliException e) {
24486       {
24487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24488       };
24489     } catch (...) {
24490       {
24491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24492       };
24493     }
24494   }
24495
24496   jresult = (void *)result;
24497   return jresult;
24498 }
24499
24500
24501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24502   void * jresult ;
24503   Dali::BaseHandle arg1 ;
24504   Dali::BaseHandle *argp1 ;
24505   Dali::Texture result;
24506
24507   argp1 = (Dali::BaseHandle *)jarg1;
24508   if (!argp1) {
24509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24510     return 0;
24511   }
24512   arg1 = *argp1;
24513   {
24514     try {
24515       result = Dali::Texture::DownCast(arg1);
24516     } catch (std::out_of_range& e) {
24517       {
24518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24519       };
24520     } catch (std::exception& e) {
24521       {
24522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24523       };
24524     } catch (Dali::DaliException e) {
24525       {
24526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24527       };
24528     } catch (...) {
24529       {
24530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24531       };
24532     }
24533   }
24534
24535   jresult = new Dali::Texture((const Dali::Texture &)result);
24536   return jresult;
24537 }
24538
24539
24540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24541   void * jresult ;
24542   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24543   Dali::Texture *arg2 = 0 ;
24544   Dali::Texture *result = 0 ;
24545
24546   arg1 = (Dali::Texture *)jarg1;
24547   arg2 = (Dali::Texture *)jarg2;
24548   if (!arg2) {
24549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24550     return 0;
24551   }
24552   {
24553     try {
24554       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24555     } catch (std::out_of_range& e) {
24556       {
24557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24558       };
24559     } catch (std::exception& e) {
24560       {
24561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24562       };
24563     } catch (Dali::DaliException e) {
24564       {
24565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24566       };
24567     } catch (...) {
24568       {
24569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24570       };
24571     }
24572   }
24573
24574   jresult = (void *)result;
24575   return jresult;
24576 }
24577
24578
24579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24580   unsigned int jresult ;
24581   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24582   Dali::PixelData arg2 ;
24583   Dali::PixelData *argp2 ;
24584   bool result;
24585
24586   arg1 = (Dali::Texture *)jarg1;
24587   argp2 = (Dali::PixelData *)jarg2;
24588   if (!argp2) {
24589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24590     return 0;
24591   }
24592   arg2 = *argp2;
24593   {
24594     try {
24595       result = (bool)(arg1)->Upload(arg2);
24596     } catch (std::out_of_range& e) {
24597       {
24598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24599       };
24600     } catch (std::exception& e) {
24601       {
24602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24603       };
24604     } catch (Dali::DaliException e) {
24605       {
24606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24607       };
24608     } catch (...) {
24609       {
24610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24611       };
24612     }
24613   }
24614
24615   jresult = result;
24616   return jresult;
24617 }
24618
24619
24620 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) {
24621   unsigned int jresult ;
24622   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24623   Dali::PixelData arg2 ;
24624   unsigned int arg3 ;
24625   unsigned int arg4 ;
24626   unsigned int arg5 ;
24627   unsigned int arg6 ;
24628   unsigned int arg7 ;
24629   unsigned int arg8 ;
24630   Dali::PixelData *argp2 ;
24631   bool result;
24632
24633   arg1 = (Dali::Texture *)jarg1;
24634   argp2 = (Dali::PixelData *)jarg2;
24635   if (!argp2) {
24636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24637     return 0;
24638   }
24639   arg2 = *argp2;
24640   arg3 = (unsigned int)jarg3;
24641   arg4 = (unsigned int)jarg4;
24642   arg5 = (unsigned int)jarg5;
24643   arg6 = (unsigned int)jarg6;
24644   arg7 = (unsigned int)jarg7;
24645   arg8 = (unsigned int)jarg8;
24646   {
24647     try {
24648       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24649     } catch (std::out_of_range& e) {
24650       {
24651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24652       };
24653     } catch (std::exception& e) {
24654       {
24655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24656       };
24657     } catch (Dali::DaliException e) {
24658       {
24659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24660       };
24661     } catch (...) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24664       };
24665     }
24666   }
24667
24668   jresult = result;
24669   return jresult;
24670 }
24671
24672
24673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24674   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24675
24676   arg1 = (Dali::Texture *)jarg1;
24677   {
24678     try {
24679       (arg1)->GenerateMipmaps();
24680     } catch (std::out_of_range& e) {
24681       {
24682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24683       };
24684     } catch (std::exception& e) {
24685       {
24686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24687       };
24688     } catch (Dali::DaliException e) {
24689       {
24690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24691       };
24692     } catch (...) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24695       };
24696     }
24697   }
24698
24699 }
24700
24701
24702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24703   unsigned int jresult ;
24704   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24705   unsigned int result;
24706
24707   arg1 = (Dali::Texture *)jarg1;
24708   {
24709     try {
24710       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24711     } catch (std::out_of_range& e) {
24712       {
24713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24714       };
24715     } catch (std::exception& e) {
24716       {
24717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24718       };
24719     } catch (Dali::DaliException e) {
24720       {
24721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24722       };
24723     } catch (...) {
24724       {
24725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24726       };
24727     }
24728   }
24729
24730   jresult = result;
24731   return jresult;
24732 }
24733
24734
24735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24736   unsigned int jresult ;
24737   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24738   unsigned int result;
24739
24740   arg1 = (Dali::Texture *)jarg1;
24741   {
24742     try {
24743       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24744     } catch (std::out_of_range& e) {
24745       {
24746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24747       };
24748     } catch (std::exception& e) {
24749       {
24750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (Dali::DaliException e) {
24753       {
24754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24755       };
24756     } catch (...) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24759       };
24760     }
24761   }
24762
24763   jresult = result;
24764   return jresult;
24765 }
24766
24767
24768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_2(void * jarg1) {
24769   void * jresult ;
24770   Dali::Internal::Texture *arg1 = (Dali::Internal::Texture *) 0 ;
24771   Dali::Texture *result = 0 ;
24772
24773   arg1 = (Dali::Internal::Texture *)jarg1;
24774   {
24775     try {
24776       result = (Dali::Texture *)new Dali::Texture(arg1);
24777     } catch (std::out_of_range& e) {
24778       {
24779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24780       };
24781     } catch (std::exception& e) {
24782       {
24783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24784       };
24785     } catch (Dali::DaliException e) {
24786       {
24787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24788       };
24789     } catch (...) {
24790       {
24791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24792       };
24793     }
24794   }
24795
24796   jresult = (void *)result;
24797   return jresult;
24798 }
24799
24800
24801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24802   void * jresult ;
24803   Dali::Sampler result;
24804
24805   {
24806     try {
24807       result = Dali::Sampler::New();
24808     } catch (std::out_of_range& e) {
24809       {
24810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24811       };
24812     } catch (std::exception& e) {
24813       {
24814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24815       };
24816     } catch (Dali::DaliException e) {
24817       {
24818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24819       };
24820     } catch (...) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24823       };
24824     }
24825   }
24826
24827   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24828   return jresult;
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24833   void * jresult ;
24834   Dali::Sampler *result = 0 ;
24835
24836   {
24837     try {
24838       result = (Dali::Sampler *)new Dali::Sampler();
24839     } catch (std::out_of_range& e) {
24840       {
24841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24842       };
24843     } catch (std::exception& e) {
24844       {
24845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24846       };
24847     } catch (Dali::DaliException e) {
24848       {
24849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24850       };
24851     } catch (...) {
24852       {
24853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24854       };
24855     }
24856   }
24857
24858   jresult = (void *)result;
24859   return jresult;
24860 }
24861
24862
24863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24864   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24865
24866   arg1 = (Dali::Sampler *)jarg1;
24867   {
24868     try {
24869       delete arg1;
24870     } catch (std::out_of_range& e) {
24871       {
24872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24873       };
24874     } catch (std::exception& e) {
24875       {
24876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24877       };
24878     } catch (Dali::DaliException e) {
24879       {
24880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24881       };
24882     } catch (...) {
24883       {
24884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24885       };
24886     }
24887   }
24888
24889 }
24890
24891
24892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24893   void * jresult ;
24894   Dali::Sampler *arg1 = 0 ;
24895   Dali::Sampler *result = 0 ;
24896
24897   arg1 = (Dali::Sampler *)jarg1;
24898   if (!arg1) {
24899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24900     return 0;
24901   }
24902   {
24903     try {
24904       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24905     } catch (std::out_of_range& e) {
24906       {
24907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24908       };
24909     } catch (std::exception& e) {
24910       {
24911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24912       };
24913     } catch (Dali::DaliException e) {
24914       {
24915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24916       };
24917     } catch (...) {
24918       {
24919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24920       };
24921     }
24922   }
24923
24924   jresult = (void *)result;
24925   return jresult;
24926 }
24927
24928
24929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24930   void * jresult ;
24931   Dali::BaseHandle arg1 ;
24932   Dali::BaseHandle *argp1 ;
24933   Dali::Sampler result;
24934
24935   argp1 = (Dali::BaseHandle *)jarg1;
24936   if (!argp1) {
24937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24938     return 0;
24939   }
24940   arg1 = *argp1;
24941   {
24942     try {
24943       result = Dali::Sampler::DownCast(arg1);
24944     } catch (std::out_of_range& e) {
24945       {
24946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24947       };
24948     } catch (std::exception& e) {
24949       {
24950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24951       };
24952     } catch (Dali::DaliException e) {
24953       {
24954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24955       };
24956     } catch (...) {
24957       {
24958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24959       };
24960     }
24961   }
24962
24963   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24964   return jresult;
24965 }
24966
24967
24968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24969   void * jresult ;
24970   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24971   Dali::Sampler *arg2 = 0 ;
24972   Dali::Sampler *result = 0 ;
24973
24974   arg1 = (Dali::Sampler *)jarg1;
24975   arg2 = (Dali::Sampler *)jarg2;
24976   if (!arg2) {
24977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24978     return 0;
24979   }
24980   {
24981     try {
24982       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24983     } catch (std::out_of_range& e) {
24984       {
24985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24986       };
24987     } catch (std::exception& e) {
24988       {
24989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24990       };
24991     } catch (Dali::DaliException e) {
24992       {
24993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24994       };
24995     } catch (...) {
24996       {
24997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24998       };
24999     }
25000   }
25001
25002   jresult = (void *)result;
25003   return jresult;
25004 }
25005
25006
25007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25008   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25009   Dali::FilterMode::Type arg2 ;
25010   Dali::FilterMode::Type arg3 ;
25011
25012   arg1 = (Dali::Sampler *)jarg1;
25013   arg2 = (Dali::FilterMode::Type)jarg2;
25014   arg3 = (Dali::FilterMode::Type)jarg3;
25015   {
25016     try {
25017       (arg1)->SetFilterMode(arg2,arg3);
25018     } catch (std::out_of_range& e) {
25019       {
25020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25021       };
25022     } catch (std::exception& e) {
25023       {
25024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25025       };
25026     } catch (Dali::DaliException e) {
25027       {
25028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25029       };
25030     } catch (...) {
25031       {
25032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25033       };
25034     }
25035   }
25036
25037 }
25038
25039
25040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25041   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25042   Dali::WrapMode::Type arg2 ;
25043   Dali::WrapMode::Type arg3 ;
25044
25045   arg1 = (Dali::Sampler *)jarg1;
25046   arg2 = (Dali::WrapMode::Type)jarg2;
25047   arg3 = (Dali::WrapMode::Type)jarg3;
25048   {
25049     try {
25050       (arg1)->SetWrapMode(arg2,arg3);
25051     } catch (std::out_of_range& e) {
25052       {
25053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25054       };
25055     } catch (std::exception& e) {
25056       {
25057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25058       };
25059     } catch (Dali::DaliException e) {
25060       {
25061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25062       };
25063     } catch (...) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25066       };
25067     }
25068   }
25069
25070 }
25071
25072
25073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25074   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25075   Dali::WrapMode::Type arg2 ;
25076   Dali::WrapMode::Type arg3 ;
25077   Dali::WrapMode::Type arg4 ;
25078
25079   arg1 = (Dali::Sampler *)jarg1;
25080   arg2 = (Dali::WrapMode::Type)jarg2;
25081   arg3 = (Dali::WrapMode::Type)jarg3;
25082   arg4 = (Dali::WrapMode::Type)jarg4;
25083   {
25084     try {
25085       (arg1)->SetWrapMode(arg2,arg3,arg4);
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25101       };
25102     }
25103   }
25104
25105 }
25106
25107
25108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25109   void * jresult ;
25110   Dali::TextureSet result;
25111
25112   {
25113     try {
25114       result = Dali::TextureSet::New();
25115     } catch (std::out_of_range& e) {
25116       {
25117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25118       };
25119     } catch (std::exception& e) {
25120       {
25121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25122       };
25123     } catch (Dali::DaliException e) {
25124       {
25125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25126       };
25127     } catch (...) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25130       };
25131     }
25132   }
25133
25134   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25135   return jresult;
25136 }
25137
25138
25139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25140   void * jresult ;
25141   Dali::TextureSet *result = 0 ;
25142
25143   {
25144     try {
25145       result = (Dali::TextureSet *)new Dali::TextureSet();
25146     } catch (std::out_of_range& e) {
25147       {
25148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25149       };
25150     } catch (std::exception& e) {
25151       {
25152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25153       };
25154     } catch (Dali::DaliException e) {
25155       {
25156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25157       };
25158     } catch (...) {
25159       {
25160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25161       };
25162     }
25163   }
25164
25165   jresult = (void *)result;
25166   return jresult;
25167 }
25168
25169
25170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25171   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25172
25173   arg1 = (Dali::TextureSet *)jarg1;
25174   {
25175     try {
25176       delete arg1;
25177     } catch (std::out_of_range& e) {
25178       {
25179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25180       };
25181     } catch (std::exception& e) {
25182       {
25183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25184       };
25185     } catch (Dali::DaliException e) {
25186       {
25187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25188       };
25189     } catch (...) {
25190       {
25191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25192       };
25193     }
25194   }
25195
25196 }
25197
25198
25199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25200   void * jresult ;
25201   Dali::TextureSet *arg1 = 0 ;
25202   Dali::TextureSet *result = 0 ;
25203
25204   arg1 = (Dali::TextureSet *)jarg1;
25205   if (!arg1) {
25206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25207     return 0;
25208   }
25209   {
25210     try {
25211       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25212     } catch (std::out_of_range& e) {
25213       {
25214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25215       };
25216     } catch (std::exception& e) {
25217       {
25218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25219       };
25220     } catch (Dali::DaliException e) {
25221       {
25222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25223       };
25224     } catch (...) {
25225       {
25226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25227       };
25228     }
25229   }
25230
25231   jresult = (void *)result;
25232   return jresult;
25233 }
25234
25235
25236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25237   void * jresult ;
25238   Dali::BaseHandle arg1 ;
25239   Dali::BaseHandle *argp1 ;
25240   Dali::TextureSet result;
25241
25242   argp1 = (Dali::BaseHandle *)jarg1;
25243   if (!argp1) {
25244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25245     return 0;
25246   }
25247   arg1 = *argp1;
25248   {
25249     try {
25250       result = Dali::TextureSet::DownCast(arg1);
25251     } catch (std::out_of_range& e) {
25252       {
25253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25254       };
25255     } catch (std::exception& e) {
25256       {
25257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25258       };
25259     } catch (Dali::DaliException e) {
25260       {
25261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25262       };
25263     } catch (...) {
25264       {
25265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25266       };
25267     }
25268   }
25269
25270   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25271   return jresult;
25272 }
25273
25274
25275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25276   void * jresult ;
25277   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25278   Dali::TextureSet *arg2 = 0 ;
25279   Dali::TextureSet *result = 0 ;
25280
25281   arg1 = (Dali::TextureSet *)jarg1;
25282   arg2 = (Dali::TextureSet *)jarg2;
25283   if (!arg2) {
25284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25285     return 0;
25286   }
25287   {
25288     try {
25289       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25290     } catch (std::out_of_range& e) {
25291       {
25292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25293       };
25294     } catch (std::exception& e) {
25295       {
25296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25297       };
25298     } catch (Dali::DaliException e) {
25299       {
25300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25301       };
25302     } catch (...) {
25303       {
25304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25305       };
25306     }
25307   }
25308
25309   jresult = (void *)result;
25310   return jresult;
25311 }
25312
25313
25314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25315   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25316   size_t arg2 ;
25317   Dali::Texture arg3 ;
25318   Dali::Texture *argp3 ;
25319
25320   arg1 = (Dali::TextureSet *)jarg1;
25321   arg2 = (size_t)jarg2;
25322   argp3 = (Dali::Texture *)jarg3;
25323   if (!argp3) {
25324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25325     return ;
25326   }
25327   arg3 = *argp3;
25328   {
25329     try {
25330       (arg1)->SetTexture(arg2,arg3);
25331     } catch (std::out_of_range& e) {
25332       {
25333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25334       };
25335     } catch (std::exception& e) {
25336       {
25337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25338       };
25339     } catch (Dali::DaliException e) {
25340       {
25341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25342       };
25343     } catch (...) {
25344       {
25345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25346       };
25347     }
25348   }
25349
25350 }
25351
25352
25353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25354   void * jresult ;
25355   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25356   size_t arg2 ;
25357   Dali::Texture result;
25358
25359   arg1 = (Dali::TextureSet *)jarg1;
25360   arg2 = (size_t)jarg2;
25361   {
25362     try {
25363       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25364     } catch (std::out_of_range& e) {
25365       {
25366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25367       };
25368     } catch (std::exception& e) {
25369       {
25370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25371       };
25372     } catch (Dali::DaliException e) {
25373       {
25374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25375       };
25376     } catch (...) {
25377       {
25378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25379       };
25380     }
25381   }
25382
25383   jresult = new Dali::Texture((const Dali::Texture &)result);
25384   return jresult;
25385 }
25386
25387
25388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25389   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25390   size_t arg2 ;
25391   Dali::Sampler arg3 ;
25392   Dali::Sampler *argp3 ;
25393
25394   arg1 = (Dali::TextureSet *)jarg1;
25395   arg2 = (size_t)jarg2;
25396   argp3 = (Dali::Sampler *)jarg3;
25397   if (!argp3) {
25398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25399     return ;
25400   }
25401   arg3 = *argp3;
25402   {
25403     try {
25404       (arg1)->SetSampler(arg2,arg3);
25405     } catch (std::out_of_range& e) {
25406       {
25407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25408       };
25409     } catch (std::exception& e) {
25410       {
25411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25412       };
25413     } catch (Dali::DaliException e) {
25414       {
25415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25416       };
25417     } catch (...) {
25418       {
25419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25420       };
25421     }
25422   }
25423
25424 }
25425
25426
25427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25428   void * jresult ;
25429   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25430   size_t arg2 ;
25431   Dali::Sampler result;
25432
25433   arg1 = (Dali::TextureSet *)jarg1;
25434   arg2 = (size_t)jarg2;
25435   {
25436     try {
25437       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25438     } catch (std::out_of_range& e) {
25439       {
25440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25441       };
25442     } catch (std::exception& e) {
25443       {
25444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25445       };
25446     } catch (Dali::DaliException e) {
25447       {
25448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25449       };
25450     } catch (...) {
25451       {
25452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25453       };
25454     }
25455   }
25456
25457   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25458   return jresult;
25459 }
25460
25461
25462 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25463   unsigned long jresult ;
25464   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25465   size_t result;
25466
25467   arg1 = (Dali::TextureSet *)jarg1;
25468   {
25469     try {
25470       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25471     } catch (std::out_of_range& e) {
25472       {
25473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25474       };
25475     } catch (std::exception& e) {
25476       {
25477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25478       };
25479     } catch (Dali::DaliException e) {
25480       {
25481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25482       };
25483     } catch (...) {
25484       {
25485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25486       };
25487     }
25488   }
25489
25490   jresult = (unsigned long)result;
25491   return jresult;
25492 }
25493
25494
25495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25496   void * jresult ;
25497   Dali::Property::Map *arg1 = 0 ;
25498   Dali::PropertyBuffer result;
25499
25500   arg1 = (Dali::Property::Map *)jarg1;
25501   if (!arg1) {
25502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25503     return 0;
25504   }
25505   {
25506     try {
25507       result = Dali::PropertyBuffer::New(*arg1);
25508     } catch (std::out_of_range& e) {
25509       {
25510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25511       };
25512     } catch (std::exception& e) {
25513       {
25514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25515       };
25516     } catch (Dali::DaliException e) {
25517       {
25518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25519       };
25520     } catch (...) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25523       };
25524     }
25525   }
25526
25527   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25528   return jresult;
25529 }
25530
25531
25532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25533   void * jresult ;
25534   Dali::PropertyBuffer *result = 0 ;
25535
25536   {
25537     try {
25538       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25539     } catch (std::out_of_range& e) {
25540       {
25541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25542       };
25543     } catch (std::exception& e) {
25544       {
25545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25546       };
25547     } catch (Dali::DaliException e) {
25548       {
25549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25550       };
25551     } catch (...) {
25552       {
25553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25554       };
25555     }
25556   }
25557
25558   jresult = (void *)result;
25559   return jresult;
25560 }
25561
25562
25563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25564   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25565
25566   arg1 = (Dali::PropertyBuffer *)jarg1;
25567   {
25568     try {
25569       delete arg1;
25570     } catch (std::out_of_range& e) {
25571       {
25572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25573       };
25574     } catch (std::exception& e) {
25575       {
25576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25577       };
25578     } catch (Dali::DaliException e) {
25579       {
25580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25581       };
25582     } catch (...) {
25583       {
25584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25585       };
25586     }
25587   }
25588
25589 }
25590
25591
25592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25593   void * jresult ;
25594   Dali::PropertyBuffer *arg1 = 0 ;
25595   Dali::PropertyBuffer *result = 0 ;
25596
25597   arg1 = (Dali::PropertyBuffer *)jarg1;
25598   if (!arg1) {
25599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25600     return 0;
25601   }
25602   {
25603     try {
25604       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25605     } catch (std::out_of_range& e) {
25606       {
25607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25608       };
25609     } catch (std::exception& e) {
25610       {
25611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25612       };
25613     } catch (Dali::DaliException e) {
25614       {
25615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25616       };
25617     } catch (...) {
25618       {
25619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25620       };
25621     }
25622   }
25623
25624   jresult = (void *)result;
25625   return jresult;
25626 }
25627
25628
25629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25630   void * jresult ;
25631   Dali::BaseHandle arg1 ;
25632   Dali::BaseHandle *argp1 ;
25633   Dali::PropertyBuffer result;
25634
25635   argp1 = (Dali::BaseHandle *)jarg1;
25636   if (!argp1) {
25637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25638     return 0;
25639   }
25640   arg1 = *argp1;
25641   {
25642     try {
25643       result = Dali::PropertyBuffer::DownCast(arg1);
25644     } catch (std::out_of_range& e) {
25645       {
25646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25647       };
25648     } catch (std::exception& e) {
25649       {
25650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25651       };
25652     } catch (Dali::DaliException e) {
25653       {
25654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25655       };
25656     } catch (...) {
25657       {
25658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25659       };
25660     }
25661   }
25662
25663   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25664   return jresult;
25665 }
25666
25667
25668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25669   void * jresult ;
25670   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25671   Dali::PropertyBuffer *arg2 = 0 ;
25672   Dali::PropertyBuffer *result = 0 ;
25673
25674   arg1 = (Dali::PropertyBuffer *)jarg1;
25675   arg2 = (Dali::PropertyBuffer *)jarg2;
25676   if (!arg2) {
25677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25678     return 0;
25679   }
25680   {
25681     try {
25682       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25683     } catch (std::out_of_range& e) {
25684       {
25685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25686       };
25687     } catch (std::exception& e) {
25688       {
25689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25690       };
25691     } catch (Dali::DaliException e) {
25692       {
25693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25694       };
25695     } catch (...) {
25696       {
25697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25698       };
25699     }
25700   }
25701
25702   jresult = (void *)result;
25703   return jresult;
25704 }
25705
25706
25707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25708   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25709   void *arg2 = (void *) 0 ;
25710   std::size_t arg3 ;
25711
25712   arg1 = (Dali::PropertyBuffer *)jarg1;
25713   arg2 = jarg2;
25714   arg3 = (std::size_t)jarg3;
25715   {
25716     try {
25717       (arg1)->SetData((void const *)arg2,arg3);
25718     } catch (std::out_of_range& e) {
25719       {
25720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25721       };
25722     } catch (std::exception& e) {
25723       {
25724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25725       };
25726     } catch (Dali::DaliException e) {
25727       {
25728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25729       };
25730     } catch (...) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25733       };
25734     }
25735   }
25736
25737 }
25738
25739
25740 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25741   unsigned long jresult ;
25742   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25743   std::size_t result;
25744
25745   arg1 = (Dali::PropertyBuffer *)jarg1;
25746   {
25747     try {
25748       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25749     } catch (std::out_of_range& e) {
25750       {
25751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25752       };
25753     } catch (std::exception& e) {
25754       {
25755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (Dali::DaliException e) {
25758       {
25759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25760       };
25761     } catch (...) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25764       };
25765     }
25766   }
25767
25768   jresult = (unsigned long)result;
25769   return jresult;
25770 }
25771
25772
25773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25774   void * jresult ;
25775   Dali::Geometry result;
25776
25777   {
25778     try {
25779       result = Dali::Geometry::New();
25780     } catch (std::out_of_range& e) {
25781       {
25782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25783       };
25784     } catch (std::exception& e) {
25785       {
25786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25787       };
25788     } catch (Dali::DaliException e) {
25789       {
25790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25791       };
25792     } catch (...) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25795       };
25796     }
25797   }
25798
25799   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25800   return jresult;
25801 }
25802
25803
25804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25805   void * jresult ;
25806   Dali::Geometry *result = 0 ;
25807
25808   {
25809     try {
25810       result = (Dali::Geometry *)new Dali::Geometry();
25811     } catch (std::out_of_range& e) {
25812       {
25813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25814       };
25815     } catch (std::exception& e) {
25816       {
25817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25818       };
25819     } catch (Dali::DaliException e) {
25820       {
25821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25822       };
25823     } catch (...) {
25824       {
25825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25826       };
25827     }
25828   }
25829
25830   jresult = (void *)result;
25831   return jresult;
25832 }
25833
25834
25835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25836   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25837
25838   arg1 = (Dali::Geometry *)jarg1;
25839   {
25840     try {
25841       delete arg1;
25842     } catch (std::out_of_range& e) {
25843       {
25844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25845       };
25846     } catch (std::exception& e) {
25847       {
25848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25849       };
25850     } catch (Dali::DaliException e) {
25851       {
25852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25853       };
25854     } catch (...) {
25855       {
25856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25857       };
25858     }
25859   }
25860
25861 }
25862
25863
25864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25865   void * jresult ;
25866   Dali::Geometry *arg1 = 0 ;
25867   Dali::Geometry *result = 0 ;
25868
25869   arg1 = (Dali::Geometry *)jarg1;
25870   if (!arg1) {
25871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25872     return 0;
25873   }
25874   {
25875     try {
25876       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25877     } catch (std::out_of_range& e) {
25878       {
25879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25880       };
25881     } catch (std::exception& e) {
25882       {
25883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25884       };
25885     } catch (Dali::DaliException e) {
25886       {
25887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25888       };
25889     } catch (...) {
25890       {
25891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25892       };
25893     }
25894   }
25895
25896   jresult = (void *)result;
25897   return jresult;
25898 }
25899
25900
25901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25902   void * jresult ;
25903   Dali::BaseHandle arg1 ;
25904   Dali::BaseHandle *argp1 ;
25905   Dali::Geometry result;
25906
25907   argp1 = (Dali::BaseHandle *)jarg1;
25908   if (!argp1) {
25909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25910     return 0;
25911   }
25912   arg1 = *argp1;
25913   {
25914     try {
25915       result = Dali::Geometry::DownCast(arg1);
25916     } catch (std::out_of_range& e) {
25917       {
25918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25919       };
25920     } catch (std::exception& e) {
25921       {
25922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25923       };
25924     } catch (Dali::DaliException e) {
25925       {
25926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25927       };
25928     } catch (...) {
25929       {
25930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25931       };
25932     }
25933   }
25934
25935   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25936   return jresult;
25937 }
25938
25939
25940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25941   void * jresult ;
25942   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25943   Dali::Geometry *arg2 = 0 ;
25944   Dali::Geometry *result = 0 ;
25945
25946   arg1 = (Dali::Geometry *)jarg1;
25947   arg2 = (Dali::Geometry *)jarg2;
25948   if (!arg2) {
25949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25950     return 0;
25951   }
25952   {
25953     try {
25954       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25955     } catch (std::out_of_range& e) {
25956       {
25957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25958       };
25959     } catch (std::exception& e) {
25960       {
25961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25962       };
25963     } catch (Dali::DaliException e) {
25964       {
25965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25966       };
25967     } catch (...) {
25968       {
25969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25970       };
25971     }
25972   }
25973
25974   jresult = (void *)result;
25975   return jresult;
25976 }
25977
25978
25979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25980   unsigned long jresult ;
25981   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25982   Dali::PropertyBuffer *arg2 = 0 ;
25983   std::size_t result;
25984
25985   arg1 = (Dali::Geometry *)jarg1;
25986   arg2 = (Dali::PropertyBuffer *)jarg2;
25987   if (!arg2) {
25988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25989     return 0;
25990   }
25991   {
25992     try {
25993       result = (arg1)->AddVertexBuffer(*arg2);
25994     } catch (std::out_of_range& e) {
25995       {
25996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25997       };
25998     } catch (std::exception& e) {
25999       {
26000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26001       };
26002     } catch (Dali::DaliException e) {
26003       {
26004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26005       };
26006     } catch (...) {
26007       {
26008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26009       };
26010     }
26011   }
26012
26013   jresult = (unsigned long)result;
26014   return jresult;
26015 }
26016
26017
26018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26019   unsigned long jresult ;
26020   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26021   std::size_t result;
26022
26023   arg1 = (Dali::Geometry *)jarg1;
26024   {
26025     try {
26026       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26027     } catch (std::out_of_range& e) {
26028       {
26029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26030       };
26031     } catch (std::exception& e) {
26032       {
26033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26034       };
26035     } catch (Dali::DaliException e) {
26036       {
26037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26038       };
26039     } catch (...) {
26040       {
26041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26042       };
26043     }
26044   }
26045
26046   jresult = (unsigned long)result;
26047   return jresult;
26048 }
26049
26050
26051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26052   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26053   std::size_t arg2 ;
26054
26055   arg1 = (Dali::Geometry *)jarg1;
26056   arg2 = (std::size_t)jarg2;
26057   {
26058     try {
26059       (arg1)->RemoveVertexBuffer(arg2);
26060     } catch (std::out_of_range& e) {
26061       {
26062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26063       };
26064     } catch (std::exception& e) {
26065       {
26066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26067       };
26068     } catch (Dali::DaliException e) {
26069       {
26070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26071       };
26072     } catch (...) {
26073       {
26074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26075       };
26076     }
26077   }
26078
26079 }
26080
26081
26082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26083   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26084   unsigned short *arg2 = (unsigned short *) 0 ;
26085   size_t arg3 ;
26086
26087   arg1 = (Dali::Geometry *)jarg1;
26088   arg2 = jarg2;
26089   arg3 = (size_t)jarg3;
26090   {
26091     try {
26092       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26093     } catch (std::out_of_range& e) {
26094       {
26095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26096       };
26097     } catch (std::exception& e) {
26098       {
26099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26100       };
26101     } catch (Dali::DaliException e) {
26102       {
26103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26104       };
26105     } catch (...) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26108       };
26109     }
26110   }
26111
26112
26113
26114 }
26115
26116
26117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26118   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26119   Dali::Geometry::Type arg2 ;
26120
26121   arg1 = (Dali::Geometry *)jarg1;
26122   arg2 = (Dali::Geometry::Type)jarg2;
26123   {
26124     try {
26125       (arg1)->SetType(arg2);
26126     } catch (std::out_of_range& e) {
26127       {
26128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26129       };
26130     } catch (std::exception& e) {
26131       {
26132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26133       };
26134     } catch (Dali::DaliException e) {
26135       {
26136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26137       };
26138     } catch (...) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26141       };
26142     }
26143   }
26144
26145 }
26146
26147
26148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26149   int jresult ;
26150   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26151   Dali::Geometry::Type result;
26152
26153   arg1 = (Dali::Geometry *)jarg1;
26154   {
26155     try {
26156       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26157     } catch (std::out_of_range& e) {
26158       {
26159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26160       };
26161     } catch (std::exception& e) {
26162       {
26163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26164       };
26165     } catch (Dali::DaliException e) {
26166       {
26167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26168       };
26169     } catch (...) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26172       };
26173     }
26174   }
26175
26176   jresult = (int)result;
26177   return jresult;
26178 }
26179
26180
26181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26182   void * jresult ;
26183   Dali::Shader::Hint *result = 0 ;
26184
26185   {
26186     try {
26187       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26188     } catch (std::out_of_range& e) {
26189       {
26190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26191       };
26192     } catch (std::exception& e) {
26193       {
26194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26195       };
26196     } catch (Dali::DaliException e) {
26197       {
26198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26199       };
26200     } catch (...) {
26201       {
26202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26203       };
26204     }
26205   }
26206
26207   jresult = (void *)result;
26208   return jresult;
26209 }
26210
26211
26212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26213   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26214
26215   arg1 = (Dali::Shader::Hint *)jarg1;
26216   {
26217     try {
26218       delete arg1;
26219     } catch (std::out_of_range& e) {
26220       {
26221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26222       };
26223     } catch (std::exception& e) {
26224       {
26225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26226       };
26227     } catch (Dali::DaliException e) {
26228       {
26229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26230       };
26231     } catch (...) {
26232       {
26233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26234       };
26235     }
26236   }
26237
26238 }
26239
26240
26241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26242   int jresult ;
26243   int result;
26244
26245   result = (int)Dali::Shader::Property::PROGRAM;
26246   jresult = (int)result;
26247   return jresult;
26248 }
26249
26250
26251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26252   void * jresult ;
26253   Dali::Shader::Property *result = 0 ;
26254
26255   {
26256     try {
26257       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26258     } catch (std::out_of_range& e) {
26259       {
26260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26261       };
26262     } catch (std::exception& e) {
26263       {
26264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26265       };
26266     } catch (Dali::DaliException e) {
26267       {
26268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26269       };
26270     } catch (...) {
26271       {
26272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26273       };
26274     }
26275   }
26276
26277   jresult = (void *)result;
26278   return jresult;
26279 }
26280
26281
26282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26283   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26284
26285   arg1 = (Dali::Shader::Property *)jarg1;
26286   {
26287     try {
26288       delete arg1;
26289     } catch (std::out_of_range& e) {
26290       {
26291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26292       };
26293     } catch (std::exception& e) {
26294       {
26295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26296       };
26297     } catch (Dali::DaliException e) {
26298       {
26299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26300       };
26301     } catch (...) {
26302       {
26303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26304       };
26305     }
26306   }
26307
26308 }
26309
26310
26311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26312   void * jresult ;
26313   std::string *arg1 = 0 ;
26314   std::string *arg2 = 0 ;
26315   Dali::Shader::Hint::Value arg3 ;
26316   Dali::Shader result;
26317
26318   if (!jarg1) {
26319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26320     return 0;
26321   }
26322   std::string arg1_str(jarg1);
26323   arg1 = &arg1_str;
26324   if (!jarg2) {
26325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26326     return 0;
26327   }
26328   std::string arg2_str(jarg2);
26329   arg2 = &arg2_str;
26330   arg3 = (Dali::Shader::Hint::Value)jarg3;
26331   {
26332     try {
26333       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26334     } catch (std::out_of_range& e) {
26335       {
26336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26337       };
26338     } catch (std::exception& e) {
26339       {
26340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26341       };
26342     } catch (Dali::DaliException e) {
26343       {
26344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26345       };
26346     } catch (...) {
26347       {
26348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26349       };
26350     }
26351   }
26352
26353   jresult = new Dali::Shader((const Dali::Shader &)result);
26354
26355   //argout typemap for const std::string&
26356
26357
26358   //argout typemap for const std::string&
26359
26360   return jresult;
26361 }
26362
26363
26364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26365   void * jresult ;
26366   std::string *arg1 = 0 ;
26367   std::string *arg2 = 0 ;
26368   Dali::Shader result;
26369
26370   if (!jarg1) {
26371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26372     return 0;
26373   }
26374   std::string arg1_str(jarg1);
26375   arg1 = &arg1_str;
26376   if (!jarg2) {
26377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26378     return 0;
26379   }
26380   std::string arg2_str(jarg2);
26381   arg2 = &arg2_str;
26382   {
26383     try {
26384       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26385     } catch (std::out_of_range& e) {
26386       {
26387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26388       };
26389     } catch (std::exception& e) {
26390       {
26391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26392       };
26393     } catch (Dali::DaliException e) {
26394       {
26395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26396       };
26397     } catch (...) {
26398       {
26399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26400       };
26401     }
26402   }
26403
26404   jresult = new Dali::Shader((const Dali::Shader &)result);
26405
26406   //argout typemap for const std::string&
26407
26408
26409   //argout typemap for const std::string&
26410
26411   return jresult;
26412 }
26413
26414
26415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26416   void * jresult ;
26417   Dali::Shader *result = 0 ;
26418
26419   {
26420     try {
26421       result = (Dali::Shader *)new Dali::Shader();
26422     } catch (std::out_of_range& e) {
26423       {
26424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26425       };
26426     } catch (std::exception& e) {
26427       {
26428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26429       };
26430     } catch (Dali::DaliException e) {
26431       {
26432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26433       };
26434     } catch (...) {
26435       {
26436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26437       };
26438     }
26439   }
26440
26441   jresult = (void *)result;
26442   return jresult;
26443 }
26444
26445
26446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26447   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26448
26449   arg1 = (Dali::Shader *)jarg1;
26450   {
26451     try {
26452       delete arg1;
26453     } catch (std::out_of_range& e) {
26454       {
26455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26456       };
26457     } catch (std::exception& e) {
26458       {
26459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26460       };
26461     } catch (Dali::DaliException e) {
26462       {
26463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26464       };
26465     } catch (...) {
26466       {
26467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26468       };
26469     }
26470   }
26471
26472 }
26473
26474
26475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26476   void * jresult ;
26477   Dali::Shader *arg1 = 0 ;
26478   Dali::Shader *result = 0 ;
26479
26480   arg1 = (Dali::Shader *)jarg1;
26481   if (!arg1) {
26482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26483     return 0;
26484   }
26485   {
26486     try {
26487       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26488     } catch (std::out_of_range& e) {
26489       {
26490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26491       };
26492     } catch (std::exception& e) {
26493       {
26494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26495       };
26496     } catch (Dali::DaliException e) {
26497       {
26498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26499       };
26500     } catch (...) {
26501       {
26502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26503       };
26504     }
26505   }
26506
26507   jresult = (void *)result;
26508   return jresult;
26509 }
26510
26511
26512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26513   void * jresult ;
26514   Dali::BaseHandle arg1 ;
26515   Dali::BaseHandle *argp1 ;
26516   Dali::Shader result;
26517
26518   argp1 = (Dali::BaseHandle *)jarg1;
26519   if (!argp1) {
26520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26521     return 0;
26522   }
26523   arg1 = *argp1;
26524   {
26525     try {
26526       result = Dali::Shader::DownCast(arg1);
26527     } catch (std::out_of_range& e) {
26528       {
26529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26530       };
26531     } catch (std::exception& e) {
26532       {
26533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26534       };
26535     } catch (Dali::DaliException e) {
26536       {
26537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26538       };
26539     } catch (...) {
26540       {
26541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26542       };
26543     }
26544   }
26545
26546   jresult = new Dali::Shader((const Dali::Shader &)result);
26547   return jresult;
26548 }
26549
26550
26551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26552   void * jresult ;
26553   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26554   Dali::Shader *arg2 = 0 ;
26555   Dali::Shader *result = 0 ;
26556
26557   arg1 = (Dali::Shader *)jarg1;
26558   arg2 = (Dali::Shader *)jarg2;
26559   if (!arg2) {
26560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26561     return 0;
26562   }
26563   {
26564     try {
26565       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26566     } catch (std::out_of_range& e) {
26567       {
26568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26569       };
26570     } catch (std::exception& e) {
26571       {
26572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26573       };
26574     } catch (Dali::DaliException e) {
26575       {
26576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26577       };
26578     } catch (...) {
26579       {
26580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26581       };
26582     }
26583   }
26584
26585   jresult = (void *)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::Renderer::Property::BLEND_MODE;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26631   int jresult ;
26632   int result;
26633
26634   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26635   jresult = (int)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26641   int jresult ;
26642   int result;
26643
26644   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26645   jresult = (int)result;
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26651   int jresult ;
26652   int result;
26653
26654   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26655   jresult = (int)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26661   int jresult ;
26662   int result;
26663
26664   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26665   jresult = (int)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26671   int jresult ;
26672   int result;
26673
26674   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26675   jresult = (int)result;
26676   return jresult;
26677 }
26678
26679
26680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26681   int jresult ;
26682   int result;
26683
26684   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26685   jresult = (int)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26691   int jresult ;
26692   int result;
26693
26694   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26695   jresult = (int)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26701   int jresult ;
26702   int result;
26703
26704   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26705   jresult = (int)result;
26706   return jresult;
26707 }
26708
26709
26710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26711   int jresult ;
26712   int result;
26713
26714   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26715   jresult = (int)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26721   int jresult ;
26722   int result;
26723
26724   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26725   jresult = (int)result;
26726   return jresult;
26727 }
26728
26729
26730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26731   int jresult ;
26732   int result;
26733
26734   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26735   jresult = (int)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26741   int jresult ;
26742   int result;
26743
26744   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26745   jresult = (int)result;
26746   return jresult;
26747 }
26748
26749
26750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26751   int jresult ;
26752   int result;
26753
26754   result = (int)Dali::Renderer::Property::RENDER_MODE;
26755   jresult = (int)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26761   int jresult ;
26762   int result;
26763
26764   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26765   jresult = (int)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26771   int jresult ;
26772   int result;
26773
26774   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26775   jresult = (int)result;
26776   return jresult;
26777 }
26778
26779
26780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26781   int jresult ;
26782   int result;
26783
26784   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26785   jresult = (int)result;
26786   return jresult;
26787 }
26788
26789
26790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26791   int jresult ;
26792   int result;
26793
26794   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26795   jresult = (int)result;
26796   return jresult;
26797 }
26798
26799
26800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26801   int jresult ;
26802   int result;
26803
26804   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26805   jresult = (int)result;
26806   return jresult;
26807 }
26808
26809
26810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26811   int jresult ;
26812   int result;
26813
26814   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26815   jresult = (int)result;
26816   return jresult;
26817 }
26818
26819
26820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26821   int jresult ;
26822   int result;
26823
26824   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26825   jresult = (int)result;
26826   return jresult;
26827 }
26828
26829
26830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26831   void * jresult ;
26832   Dali::Renderer::Property *result = 0 ;
26833
26834   {
26835     try {
26836       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26837     } catch (std::out_of_range& e) {
26838       {
26839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26840       };
26841     } catch (std::exception& e) {
26842       {
26843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26844       };
26845     } catch (Dali::DaliException e) {
26846       {
26847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26848       };
26849     } catch (...) {
26850       {
26851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26852       };
26853     }
26854   }
26855
26856   jresult = (void *)result;
26857   return jresult;
26858 }
26859
26860
26861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26862   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26863
26864   arg1 = (Dali::Renderer::Property *)jarg1;
26865   {
26866     try {
26867       delete arg1;
26868     } catch (std::out_of_range& e) {
26869       {
26870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26871       };
26872     } catch (std::exception& e) {
26873       {
26874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26875       };
26876     } catch (Dali::DaliException e) {
26877       {
26878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26879       };
26880     } catch (...) {
26881       {
26882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26883       };
26884     }
26885   }
26886
26887 }
26888
26889
26890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26891   void * jresult ;
26892   Dali::Geometry *arg1 = 0 ;
26893   Dali::Shader *arg2 = 0 ;
26894   Dali::Renderer result;
26895
26896   arg1 = (Dali::Geometry *)jarg1;
26897   if (!arg1) {
26898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26899     return 0;
26900   }
26901   arg2 = (Dali::Shader *)jarg2;
26902   if (!arg2) {
26903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26904     return 0;
26905   }
26906   {
26907     try {
26908       result = Dali::Renderer::New(*arg1,*arg2);
26909     } catch (std::out_of_range& e) {
26910       {
26911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26912       };
26913     } catch (std::exception& e) {
26914       {
26915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26916       };
26917     } catch (Dali::DaliException e) {
26918       {
26919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26920       };
26921     } catch (...) {
26922       {
26923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26924       };
26925     }
26926   }
26927
26928   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26929   return jresult;
26930 }
26931
26932
26933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26934   void * jresult ;
26935   Dali::Renderer *result = 0 ;
26936
26937   {
26938     try {
26939       result = (Dali::Renderer *)new Dali::Renderer();
26940     } catch (std::out_of_range& e) {
26941       {
26942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26943       };
26944     } catch (std::exception& e) {
26945       {
26946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26947       };
26948     } catch (Dali::DaliException e) {
26949       {
26950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26951       };
26952     } catch (...) {
26953       {
26954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26955       };
26956     }
26957   }
26958
26959   jresult = (void *)result;
26960   return jresult;
26961 }
26962
26963
26964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26965   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26966
26967   arg1 = (Dali::Renderer *)jarg1;
26968   {
26969     try {
26970       delete arg1;
26971     } catch (std::out_of_range& e) {
26972       {
26973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26974       };
26975     } catch (std::exception& e) {
26976       {
26977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26978       };
26979     } catch (Dali::DaliException e) {
26980       {
26981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26982       };
26983     } catch (...) {
26984       {
26985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26986       };
26987     }
26988   }
26989
26990 }
26991
26992
26993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26994   void * jresult ;
26995   Dali::Renderer *arg1 = 0 ;
26996   Dali::Renderer *result = 0 ;
26997
26998   arg1 = (Dali::Renderer *)jarg1;
26999   if (!arg1) {
27000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27001     return 0;
27002   }
27003   {
27004     try {
27005       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27006     } catch (std::out_of_range& e) {
27007       {
27008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27009       };
27010     } catch (std::exception& e) {
27011       {
27012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27013       };
27014     } catch (Dali::DaliException e) {
27015       {
27016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27017       };
27018     } catch (...) {
27019       {
27020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27021       };
27022     }
27023   }
27024
27025   jresult = (void *)result;
27026   return jresult;
27027 }
27028
27029
27030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27031   void * jresult ;
27032   Dali::BaseHandle arg1 ;
27033   Dali::BaseHandle *argp1 ;
27034   Dali::Renderer result;
27035
27036   argp1 = (Dali::BaseHandle *)jarg1;
27037   if (!argp1) {
27038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27039     return 0;
27040   }
27041   arg1 = *argp1;
27042   {
27043     try {
27044       result = Dali::Renderer::DownCast(arg1);
27045     } catch (std::out_of_range& e) {
27046       {
27047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27048       };
27049     } catch (std::exception& e) {
27050       {
27051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27052       };
27053     } catch (Dali::DaliException e) {
27054       {
27055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27056       };
27057     } catch (...) {
27058       {
27059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27060       };
27061     }
27062   }
27063
27064   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27065   return jresult;
27066 }
27067
27068
27069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27070   void * jresult ;
27071   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27072   Dali::Renderer *arg2 = 0 ;
27073   Dali::Renderer *result = 0 ;
27074
27075   arg1 = (Dali::Renderer *)jarg1;
27076   arg2 = (Dali::Renderer *)jarg2;
27077   if (!arg2) {
27078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27079     return 0;
27080   }
27081   {
27082     try {
27083       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27084     } catch (std::out_of_range& e) {
27085       {
27086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27087       };
27088     } catch (std::exception& e) {
27089       {
27090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (Dali::DaliException e) {
27093       {
27094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27095       };
27096     } catch (...) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27099       };
27100     }
27101   }
27102
27103   jresult = (void *)result;
27104   return jresult;
27105 }
27106
27107
27108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27109   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27110   Dali::Geometry *arg2 = 0 ;
27111
27112   arg1 = (Dali::Renderer *)jarg1;
27113   arg2 = (Dali::Geometry *)jarg2;
27114   if (!arg2) {
27115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27116     return ;
27117   }
27118   {
27119     try {
27120       (arg1)->SetGeometry(*arg2);
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27128       };
27129     } catch (Dali::DaliException e) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27132       };
27133     } catch (...) {
27134       {
27135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27136       };
27137     }
27138   }
27139
27140 }
27141
27142
27143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27144   void * jresult ;
27145   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27146   Dali::Geometry result;
27147
27148   arg1 = (Dali::Renderer *)jarg1;
27149   {
27150     try {
27151       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27152     } catch (std::out_of_range& e) {
27153       {
27154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27155       };
27156     } catch (std::exception& e) {
27157       {
27158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (Dali::DaliException e) {
27161       {
27162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27163       };
27164     } catch (...) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27167       };
27168     }
27169   }
27170
27171   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27172   return jresult;
27173 }
27174
27175
27176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27177   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27178   int arg2 ;
27179   int arg3 ;
27180
27181   arg1 = (Dali::Renderer *)jarg1;
27182   arg2 = (int)jarg2;
27183   arg3 = (int)jarg3;
27184   {
27185     try {
27186       (arg1)->SetIndexRange(arg2,arg3);
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27202       };
27203     }
27204   }
27205
27206 }
27207
27208
27209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27210   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27211   Dali::TextureSet *arg2 = 0 ;
27212
27213   arg1 = (Dali::Renderer *)jarg1;
27214   arg2 = (Dali::TextureSet *)jarg2;
27215   if (!arg2) {
27216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27217     return ;
27218   }
27219   {
27220     try {
27221       (arg1)->SetTextures(*arg2);
27222     } catch (std::out_of_range& e) {
27223       {
27224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27225       };
27226     } catch (std::exception& e) {
27227       {
27228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27229       };
27230     } catch (Dali::DaliException e) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27233       };
27234     } catch (...) {
27235       {
27236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27237       };
27238     }
27239   }
27240
27241 }
27242
27243
27244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27245   void * jresult ;
27246   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27247   Dali::TextureSet result;
27248
27249   arg1 = (Dali::Renderer *)jarg1;
27250   {
27251     try {
27252       result = ((Dali::Renderer const *)arg1)->GetTextures();
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271
27272   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27273   return jresult;
27274 }
27275
27276
27277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27278   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27279   Dali::Shader *arg2 = 0 ;
27280
27281   arg1 = (Dali::Renderer *)jarg1;
27282   arg2 = (Dali::Shader *)jarg2;
27283   if (!arg2) {
27284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27285     return ;
27286   }
27287   {
27288     try {
27289       (arg1)->SetShader(*arg2);
27290     } catch (std::out_of_range& e) {
27291       {
27292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27293       };
27294     } catch (std::exception& e) {
27295       {
27296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27297       };
27298     } catch (Dali::DaliException e) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27301       };
27302     } catch (...) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27305       };
27306     }
27307   }
27308
27309 }
27310
27311
27312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27313   void * jresult ;
27314   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27315   Dali::Shader result;
27316
27317   arg1 = (Dali::Renderer *)jarg1;
27318   {
27319     try {
27320       result = ((Dali::Renderer const *)arg1)->GetShader();
27321     } catch (std::out_of_range& e) {
27322       {
27323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (std::exception& e) {
27326       {
27327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27328       };
27329     } catch (Dali::DaliException e) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27332       };
27333     } catch (...) {
27334       {
27335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27336       };
27337     }
27338   }
27339
27340   jresult = new Dali::Shader((const Dali::Shader &)result);
27341   return jresult;
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27346   void * jresult ;
27347   Dali::FrameBuffer::Attachment *result = 0 ;
27348
27349   {
27350     try {
27351       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27352     } catch (std::out_of_range& e) {
27353       {
27354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27355       };
27356     } catch (std::exception& e) {
27357       {
27358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27359       };
27360     } catch (Dali::DaliException e) {
27361       {
27362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27363       };
27364     } catch (...) {
27365       {
27366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27367       };
27368     }
27369   }
27370
27371   jresult = (void *)result;
27372   return jresult;
27373 }
27374
27375
27376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27377   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27378
27379   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27380   {
27381     try {
27382       delete arg1;
27383     } catch (std::out_of_range& e) {
27384       {
27385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27386       };
27387     } catch (std::exception& e) {
27388       {
27389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27390       };
27391     } catch (Dali::DaliException e) {
27392       {
27393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27394       };
27395     } catch (...) {
27396       {
27397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27398       };
27399     }
27400   }
27401
27402 }
27403
27404
27405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27406   void * jresult ;
27407   unsigned int arg1 ;
27408   unsigned int arg2 ;
27409   unsigned int arg3 ;
27410   Dali::FrameBuffer result;
27411
27412   arg1 = (unsigned int)jarg1;
27413   arg2 = (unsigned int)jarg2;
27414   arg3 = (unsigned int)jarg3;
27415   {
27416     try {
27417       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27418     } catch (std::out_of_range& e) {
27419       {
27420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27421       };
27422     } catch (std::exception& e) {
27423       {
27424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27425       };
27426     } catch (Dali::DaliException e) {
27427       {
27428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27429       };
27430     } catch (...) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27433       };
27434     }
27435   }
27436
27437   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27438   return jresult;
27439 }
27440
27441
27442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27443   void * jresult ;
27444   Dali::FrameBuffer *result = 0 ;
27445
27446   {
27447     try {
27448       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27449     } catch (std::out_of_range& e) {
27450       {
27451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27452       };
27453     } catch (std::exception& e) {
27454       {
27455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27456       };
27457     } catch (Dali::DaliException e) {
27458       {
27459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27460       };
27461     } catch (...) {
27462       {
27463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27464       };
27465     }
27466   }
27467
27468   jresult = (void *)result;
27469   return jresult;
27470 }
27471
27472
27473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27474   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27475
27476   arg1 = (Dali::FrameBuffer *)jarg1;
27477   {
27478     try {
27479       delete arg1;
27480     } catch (std::out_of_range& e) {
27481       {
27482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27483       };
27484     } catch (std::exception& e) {
27485       {
27486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27487       };
27488     } catch (Dali::DaliException e) {
27489       {
27490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27491       };
27492     } catch (...) {
27493       {
27494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27495       };
27496     }
27497   }
27498
27499 }
27500
27501
27502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27503   void * jresult ;
27504   Dali::FrameBuffer *arg1 = 0 ;
27505   Dali::FrameBuffer *result = 0 ;
27506
27507   arg1 = (Dali::FrameBuffer *)jarg1;
27508   if (!arg1) {
27509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27510     return 0;
27511   }
27512   {
27513     try {
27514       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27515     } catch (std::out_of_range& e) {
27516       {
27517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27518       };
27519     } catch (std::exception& e) {
27520       {
27521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27522       };
27523     } catch (Dali::DaliException e) {
27524       {
27525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27526       };
27527     } catch (...) {
27528       {
27529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27530       };
27531     }
27532   }
27533
27534   jresult = (void *)result;
27535   return jresult;
27536 }
27537
27538
27539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27540   void * jresult ;
27541   Dali::BaseHandle arg1 ;
27542   Dali::BaseHandle *argp1 ;
27543   Dali::FrameBuffer result;
27544
27545   argp1 = (Dali::BaseHandle *)jarg1;
27546   if (!argp1) {
27547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27548     return 0;
27549   }
27550   arg1 = *argp1;
27551   {
27552     try {
27553       result = Dali::FrameBuffer::DownCast(arg1);
27554     } catch (std::out_of_range& e) {
27555       {
27556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27557       };
27558     } catch (std::exception& e) {
27559       {
27560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27561       };
27562     } catch (Dali::DaliException e) {
27563       {
27564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27565       };
27566     } catch (...) {
27567       {
27568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27569       };
27570     }
27571   }
27572
27573   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27574   return jresult;
27575 }
27576
27577
27578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27579   void * jresult ;
27580   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27581   Dali::FrameBuffer *arg2 = 0 ;
27582   Dali::FrameBuffer *result = 0 ;
27583
27584   arg1 = (Dali::FrameBuffer *)jarg1;
27585   arg2 = (Dali::FrameBuffer *)jarg2;
27586   if (!arg2) {
27587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27588     return 0;
27589   }
27590   {
27591     try {
27592       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27593     } catch (std::out_of_range& e) {
27594       {
27595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27596       };
27597     } catch (std::exception& e) {
27598       {
27599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27600       };
27601     } catch (Dali::DaliException e) {
27602       {
27603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27604       };
27605     } catch (...) {
27606       {
27607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27608       };
27609     }
27610   }
27611
27612   jresult = (void *)result;
27613   return jresult;
27614 }
27615
27616
27617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27618   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27619   Dali::Texture *arg2 = 0 ;
27620
27621   arg1 = (Dali::FrameBuffer *)jarg1;
27622   arg2 = (Dali::Texture *)jarg2;
27623   if (!arg2) {
27624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27625     return ;
27626   }
27627   {
27628     try {
27629       (arg1)->AttachColorTexture(*arg2);
27630     } catch (std::out_of_range& e) {
27631       {
27632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27633       };
27634     } catch (std::exception& e) {
27635       {
27636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27637       };
27638     } catch (Dali::DaliException e) {
27639       {
27640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27641       };
27642     } catch (...) {
27643       {
27644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27645       };
27646     }
27647   }
27648
27649 }
27650
27651
27652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27653   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27654   Dali::Texture *arg2 = 0 ;
27655   unsigned int arg3 ;
27656   unsigned int arg4 ;
27657
27658   arg1 = (Dali::FrameBuffer *)jarg1;
27659   arg2 = (Dali::Texture *)jarg2;
27660   if (!arg2) {
27661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27662     return ;
27663   }
27664   arg3 = (unsigned int)jarg3;
27665   arg4 = (unsigned int)jarg4;
27666   {
27667     try {
27668       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27669     } catch (std::out_of_range& e) {
27670       {
27671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27672       };
27673     } catch (std::exception& e) {
27674       {
27675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27676       };
27677     } catch (Dali::DaliException e) {
27678       {
27679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27680       };
27681     } catch (...) {
27682       {
27683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27684       };
27685     }
27686   }
27687
27688 }
27689
27690
27691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27692   void * jresult ;
27693   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27694   Dali::Texture result;
27695
27696   arg1 = (Dali::FrameBuffer *)jarg1;
27697   {
27698     try {
27699       result = (arg1)->GetColorTexture();
27700     } catch (std::out_of_range& e) {
27701       {
27702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27703       };
27704     } catch (std::exception& e) {
27705       {
27706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27707       };
27708     } catch (Dali::DaliException e) {
27709       {
27710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27711       };
27712     } catch (...) {
27713       {
27714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27715       };
27716     }
27717   }
27718
27719   jresult = new Dali::Texture((const Dali::Texture &)result);
27720   return jresult;
27721 }
27722
27723
27724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27725   void * jresult ;
27726   Dali::RenderTaskList *result = 0 ;
27727
27728   {
27729     try {
27730       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27731     } catch (std::out_of_range& e) {
27732       {
27733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27734       };
27735     } catch (std::exception& e) {
27736       {
27737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27738       };
27739     } catch (Dali::DaliException e) {
27740       {
27741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27742       };
27743     } catch (...) {
27744       {
27745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27746       };
27747     }
27748   }
27749
27750   jresult = (void *)result;
27751   return jresult;
27752 }
27753
27754
27755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27756   void * jresult ;
27757   Dali::BaseHandle arg1 ;
27758   Dali::BaseHandle *argp1 ;
27759   Dali::RenderTaskList result;
27760
27761   argp1 = (Dali::BaseHandle *)jarg1;
27762   if (!argp1) {
27763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27764     return 0;
27765   }
27766   arg1 = *argp1;
27767   {
27768     try {
27769       result = Dali::RenderTaskList::DownCast(arg1);
27770     } catch (std::out_of_range& e) {
27771       {
27772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27773       };
27774     } catch (std::exception& e) {
27775       {
27776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27777       };
27778     } catch (Dali::DaliException e) {
27779       {
27780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27781       };
27782     } catch (...) {
27783       {
27784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27785       };
27786     }
27787   }
27788
27789   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27790   return jresult;
27791 }
27792
27793
27794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27795   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27796
27797   arg1 = (Dali::RenderTaskList *)jarg1;
27798   {
27799     try {
27800       delete arg1;
27801     } catch (std::out_of_range& e) {
27802       {
27803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27804       };
27805     } catch (std::exception& e) {
27806       {
27807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27808       };
27809     } catch (Dali::DaliException e) {
27810       {
27811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27812       };
27813     } catch (...) {
27814       {
27815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27816       };
27817     }
27818   }
27819
27820 }
27821
27822
27823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27824   void * jresult ;
27825   Dali::RenderTaskList *arg1 = 0 ;
27826   Dali::RenderTaskList *result = 0 ;
27827
27828   arg1 = (Dali::RenderTaskList *)jarg1;
27829   if (!arg1) {
27830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27831     return 0;
27832   }
27833   {
27834     try {
27835       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27836     } catch (std::out_of_range& e) {
27837       {
27838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27839       };
27840     } catch (std::exception& e) {
27841       {
27842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27843       };
27844     } catch (Dali::DaliException e) {
27845       {
27846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27847       };
27848     } catch (...) {
27849       {
27850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27851       };
27852     }
27853   }
27854
27855   jresult = (void *)result;
27856   return jresult;
27857 }
27858
27859
27860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27861   void * jresult ;
27862   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27863   Dali::RenderTaskList *arg2 = 0 ;
27864   Dali::RenderTaskList *result = 0 ;
27865
27866   arg1 = (Dali::RenderTaskList *)jarg1;
27867   arg2 = (Dali::RenderTaskList *)jarg2;
27868   if (!arg2) {
27869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27870     return 0;
27871   }
27872   {
27873     try {
27874       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27875     } catch (std::out_of_range& e) {
27876       {
27877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27878       };
27879     } catch (std::exception& e) {
27880       {
27881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27882       };
27883     } catch (Dali::DaliException e) {
27884       {
27885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27886       };
27887     } catch (...) {
27888       {
27889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27890       };
27891     }
27892   }
27893
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27900   void * jresult ;
27901   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27902   Dali::RenderTask result;
27903
27904   arg1 = (Dali::RenderTaskList *)jarg1;
27905   {
27906     try {
27907       result = (arg1)->CreateTask();
27908     } catch (std::out_of_range& e) {
27909       {
27910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27911       };
27912     } catch (std::exception& e) {
27913       {
27914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27915       };
27916     } catch (Dali::DaliException e) {
27917       {
27918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27919       };
27920     } catch (...) {
27921       {
27922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27923       };
27924     }
27925   }
27926
27927   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27928   return jresult;
27929 }
27930
27931
27932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27933   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27934   Dali::RenderTask arg2 ;
27935   Dali::RenderTask *argp2 ;
27936
27937   arg1 = (Dali::RenderTaskList *)jarg1;
27938   argp2 = (Dali::RenderTask *)jarg2;
27939   if (!argp2) {
27940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27941     return ;
27942   }
27943   arg2 = *argp2;
27944   {
27945     try {
27946       (arg1)->RemoveTask(arg2);
27947     } catch (std::out_of_range& e) {
27948       {
27949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27950       };
27951     } catch (std::exception& e) {
27952       {
27953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27954       };
27955     } catch (Dali::DaliException e) {
27956       {
27957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27958       };
27959     } catch (...) {
27960       {
27961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27962       };
27963     }
27964   }
27965
27966 }
27967
27968
27969 //// ===============================================end part 1 =================
27970
27971 //// ========================= part 2 ===============================
27972
27973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27974   unsigned int jresult ;
27975   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27976   unsigned int result;
27977
27978   arg1 = (Dali::RenderTaskList *)jarg1;
27979   {
27980     try {
27981       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27982     } catch (std::out_of_range& e) {
27983       {
27984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27985       };
27986     } catch (std::exception& e) {
27987       {
27988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27989       };
27990     } catch (Dali::DaliException e) {
27991       {
27992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27993       };
27994     } catch (...) {
27995       {
27996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27997       };
27998     }
27999   }
28000
28001   jresult = result;
28002   return jresult;
28003 }
28004
28005
28006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28007   void * jresult ;
28008   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28009   unsigned int arg2 ;
28010   Dali::RenderTask result;
28011
28012   arg1 = (Dali::RenderTaskList *)jarg1;
28013   arg2 = (unsigned int)jarg2;
28014   {
28015     try {
28016       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28017     } catch (std::out_of_range& e) {
28018       {
28019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28020       };
28021     } catch (std::exception& e) {
28022       {
28023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28024       };
28025     } catch (Dali::DaliException e) {
28026       {
28027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28028       };
28029     } catch (...) {
28030       {
28031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28032       };
28033     }
28034   }
28035
28036   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28037   return jresult;
28038 }
28039
28040
28041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28042   int jresult ;
28043   int result;
28044
28045   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28046   jresult = (int)result;
28047   return jresult;
28048 }
28049
28050
28051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28052   int jresult ;
28053   int result;
28054
28055   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28056   jresult = (int)result;
28057   return jresult;
28058 }
28059
28060
28061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28062   int jresult ;
28063   int result;
28064
28065   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28066   jresult = (int)result;
28067   return jresult;
28068 }
28069
28070
28071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28072   int jresult ;
28073   int result;
28074
28075   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28076   jresult = (int)result;
28077   return jresult;
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28082   void * jresult ;
28083   Dali::RenderTask::Property *result = 0 ;
28084
28085   {
28086     try {
28087       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28088     } catch (std::out_of_range& e) {
28089       {
28090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28091       };
28092     } catch (std::exception& e) {
28093       {
28094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28095       };
28096     } catch (Dali::DaliException e) {
28097       {
28098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28099       };
28100     } catch (...) {
28101       {
28102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28103       };
28104     }
28105   }
28106
28107   jresult = (void *)result;
28108   return jresult;
28109 }
28110
28111
28112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28113   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28114
28115   arg1 = (Dali::RenderTask::Property *)jarg1;
28116   {
28117     try {
28118       delete arg1;
28119     } catch (std::out_of_range& e) {
28120       {
28121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28122       };
28123     } catch (std::exception& e) {
28124       {
28125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28126       };
28127     } catch (Dali::DaliException e) {
28128       {
28129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28130       };
28131     } catch (...) {
28132       {
28133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28134       };
28135     }
28136   }
28137
28138 }
28139
28140
28141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28142   void * jresult ;
28143   bool (*result)(Dali::Vector2 &) = 0 ;
28144
28145   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28146   jresult = (void *)result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28152   void * jresult ;
28153   bool (*result)(Dali::Vector2 &) = 0 ;
28154
28155   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28156   jresult = (void *)result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28162   unsigned int jresult ;
28163   bool result;
28164
28165   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28166   jresult = result;
28167   return jresult;
28168 }
28169
28170
28171 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28172   unsigned int jresult ;
28173   bool result;
28174
28175   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28176   jresult = result;
28177   return jresult;
28178 }
28179
28180
28181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28182   void * jresult ;
28183   Dali::Vector4 *result = 0 ;
28184
28185   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28186   jresult = (void *)result;
28187   return jresult;
28188 }
28189
28190
28191 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28192   unsigned int jresult ;
28193   bool result;
28194
28195   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28196   jresult = result;
28197   return jresult;
28198 }
28199
28200
28201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28202   unsigned int jresult ;
28203   bool result;
28204
28205   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28206   jresult = result;
28207   return jresult;
28208 }
28209
28210
28211 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28212   unsigned int jresult ;
28213   unsigned int result;
28214
28215   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28216   jresult = result;
28217   return jresult;
28218 }
28219
28220
28221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28222   void * jresult ;
28223   Dali::RenderTask *result = 0 ;
28224
28225   {
28226     try {
28227       result = (Dali::RenderTask *)new Dali::RenderTask();
28228     } catch (std::out_of_range& e) {
28229       {
28230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28231       };
28232     } catch (std::exception& e) {
28233       {
28234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28235       };
28236     } catch (Dali::DaliException e) {
28237       {
28238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28239       };
28240     } catch (...) {
28241       {
28242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28243       };
28244     }
28245   }
28246
28247   jresult = (void *)result;
28248   return jresult;
28249 }
28250
28251
28252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28253   void * jresult ;
28254   Dali::BaseHandle arg1 ;
28255   Dali::BaseHandle *argp1 ;
28256   Dali::RenderTask result;
28257
28258   argp1 = (Dali::BaseHandle *)jarg1;
28259   if (!argp1) {
28260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28261     return 0;
28262   }
28263   arg1 = *argp1;
28264   {
28265     try {
28266       result = Dali::RenderTask::DownCast(arg1);
28267     } catch (std::out_of_range& e) {
28268       {
28269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28270       };
28271     } catch (std::exception& e) {
28272       {
28273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28274       };
28275     } catch (Dali::DaliException e) {
28276       {
28277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28278       };
28279     } catch (...) {
28280       {
28281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28282       };
28283     }
28284   }
28285
28286   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28287   return jresult;
28288 }
28289
28290
28291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28292   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28293
28294   arg1 = (Dali::RenderTask *)jarg1;
28295   {
28296     try {
28297       delete arg1;
28298     } catch (std::out_of_range& e) {
28299       {
28300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28301       };
28302     } catch (std::exception& e) {
28303       {
28304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28305       };
28306     } catch (Dali::DaliException e) {
28307       {
28308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28309       };
28310     } catch (...) {
28311       {
28312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28313       };
28314     }
28315   }
28316
28317 }
28318
28319
28320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28321   void * jresult ;
28322   Dali::RenderTask *arg1 = 0 ;
28323   Dali::RenderTask *result = 0 ;
28324
28325   arg1 = (Dali::RenderTask *)jarg1;
28326   if (!arg1) {
28327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28328     return 0;
28329   }
28330   {
28331     try {
28332       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28333     } catch (std::out_of_range& e) {
28334       {
28335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28336       };
28337     } catch (std::exception& e) {
28338       {
28339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28340       };
28341     } catch (Dali::DaliException e) {
28342       {
28343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28344       };
28345     } catch (...) {
28346       {
28347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28348       };
28349     }
28350   }
28351
28352   jresult = (void *)result;
28353   return jresult;
28354 }
28355
28356
28357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28358   void * jresult ;
28359   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28360   Dali::RenderTask *arg2 = 0 ;
28361   Dali::RenderTask *result = 0 ;
28362
28363   arg1 = (Dali::RenderTask *)jarg1;
28364   arg2 = (Dali::RenderTask *)jarg2;
28365   if (!arg2) {
28366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28367     return 0;
28368   }
28369   {
28370     try {
28371       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28372     } catch (std::out_of_range& e) {
28373       {
28374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28375       };
28376     } catch (std::exception& e) {
28377       {
28378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28379       };
28380     } catch (Dali::DaliException e) {
28381       {
28382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28383       };
28384     } catch (...) {
28385       {
28386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28387       };
28388     }
28389   }
28390
28391   jresult = (void *)result;
28392   return jresult;
28393 }
28394
28395
28396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28397   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28398   Dali::Actor arg2 ;
28399   Dali::Actor *argp2 ;
28400
28401   arg1 = (Dali::RenderTask *)jarg1;
28402   argp2 = (Dali::Actor *)jarg2;
28403   if (!argp2) {
28404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28405     return ;
28406   }
28407   arg2 = *argp2;
28408   {
28409     try {
28410       (arg1)->SetSourceActor(arg2);
28411     } catch (std::out_of_range& e) {
28412       {
28413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28414       };
28415     } catch (std::exception& e) {
28416       {
28417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (Dali::DaliException e) {
28420       {
28421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28422       };
28423     } catch (...) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28426       };
28427     }
28428   }
28429
28430 }
28431
28432
28433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28434   void * jresult ;
28435   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28436   Dali::Actor result;
28437
28438   arg1 = (Dali::RenderTask *)jarg1;
28439   {
28440     try {
28441       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28442     } catch (std::out_of_range& e) {
28443       {
28444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28445       };
28446     } catch (std::exception& e) {
28447       {
28448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (Dali::DaliException e) {
28451       {
28452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28453       };
28454     } catch (...) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28457       };
28458     }
28459   }
28460
28461   jresult = new Dali::Actor((const Dali::Actor &)result);
28462   return jresult;
28463 }
28464
28465
28466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28467   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28468   bool arg2 ;
28469
28470   arg1 = (Dali::RenderTask *)jarg1;
28471   arg2 = jarg2 ? true : false;
28472   {
28473     try {
28474       (arg1)->SetExclusive(arg2);
28475     } catch (std::out_of_range& e) {
28476       {
28477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (std::exception& e) {
28480       {
28481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (Dali::DaliException e) {
28484       {
28485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28486       };
28487     } catch (...) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28490       };
28491     }
28492   }
28493
28494 }
28495
28496
28497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28498   unsigned int jresult ;
28499   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28500   bool result;
28501
28502   arg1 = (Dali::RenderTask *)jarg1;
28503   {
28504     try {
28505       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28521       };
28522     }
28523   }
28524
28525   jresult = result;
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28532   bool arg2 ;
28533
28534   arg1 = (Dali::RenderTask *)jarg1;
28535   arg2 = jarg2 ? true : false;
28536   {
28537     try {
28538       (arg1)->SetInputEnabled(arg2);
28539     } catch (std::out_of_range& e) {
28540       {
28541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28542       };
28543     } catch (std::exception& e) {
28544       {
28545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28546       };
28547     } catch (Dali::DaliException e) {
28548       {
28549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28550       };
28551     } catch (...) {
28552       {
28553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28554       };
28555     }
28556   }
28557
28558 }
28559
28560
28561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28562   unsigned int jresult ;
28563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28564   bool result;
28565
28566   arg1 = (Dali::RenderTask *)jarg1;
28567   {
28568     try {
28569       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28570     } catch (std::out_of_range& e) {
28571       {
28572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28573       };
28574     } catch (std::exception& e) {
28575       {
28576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28577       };
28578     } catch (Dali::DaliException e) {
28579       {
28580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28581       };
28582     } catch (...) {
28583       {
28584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28585       };
28586     }
28587   }
28588
28589   jresult = result;
28590   return jresult;
28591 }
28592
28593
28594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28595   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28596   Dali::CameraActor arg2 ;
28597   Dali::CameraActor *argp2 ;
28598
28599   arg1 = (Dali::RenderTask *)jarg1;
28600   argp2 = (Dali::CameraActor *)jarg2;
28601   if (!argp2) {
28602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28603     return ;
28604   }
28605   arg2 = *argp2;
28606   {
28607     try {
28608       (arg1)->SetCameraActor(arg2);
28609     } catch (std::out_of_range& e) {
28610       {
28611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28612       };
28613     } catch (std::exception& e) {
28614       {
28615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28616       };
28617     } catch (Dali::DaliException e) {
28618       {
28619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28620       };
28621     } catch (...) {
28622       {
28623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28624       };
28625     }
28626   }
28627
28628 }
28629
28630
28631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28632   void * jresult ;
28633   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28634   Dali::CameraActor result;
28635
28636   arg1 = (Dali::RenderTask *)jarg1;
28637   {
28638     try {
28639       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28640     } catch (std::out_of_range& e) {
28641       {
28642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28643       };
28644     } catch (std::exception& e) {
28645       {
28646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28647       };
28648     } catch (Dali::DaliException e) {
28649       {
28650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28651       };
28652     } catch (...) {
28653       {
28654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28655       };
28656     }
28657   }
28658
28659   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28660   return jresult;
28661 }
28662
28663
28664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28665   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28666   Dali::FrameBufferImage arg2 ;
28667   Dali::FrameBufferImage *argp2 ;
28668
28669   arg1 = (Dali::RenderTask *)jarg1;
28670   argp2 = (Dali::FrameBufferImage *)jarg2;
28671   if (!argp2) {
28672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28673     return ;
28674   }
28675   arg2 = *argp2;
28676   {
28677     try {
28678       (arg1)->SetTargetFrameBuffer(arg2);
28679     } catch (std::out_of_range& e) {
28680       {
28681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28682       };
28683     } catch (std::exception& e) {
28684       {
28685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28686       };
28687     } catch (Dali::DaliException e) {
28688       {
28689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28690       };
28691     } catch (...) {
28692       {
28693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28694       };
28695     }
28696   }
28697
28698 }
28699
28700
28701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28702   void * jresult ;
28703   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28704   Dali::FrameBufferImage result;
28705
28706   arg1 = (Dali::RenderTask *)jarg1;
28707   {
28708     try {
28709       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28710     } catch (std::out_of_range& e) {
28711       {
28712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28713       };
28714     } catch (std::exception& e) {
28715       {
28716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28717       };
28718     } catch (Dali::DaliException e) {
28719       {
28720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28721       };
28722     } catch (...) {
28723       {
28724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28725       };
28726     }
28727   }
28728
28729   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28730   return jresult;
28731 }
28732
28733
28734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28735   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28736   Dali::FrameBuffer arg2 ;
28737   Dali::FrameBuffer *argp2 ;
28738
28739   arg1 = (Dali::RenderTask *)jarg1;
28740   argp2 = (Dali::FrameBuffer *)jarg2;
28741   if (!argp2) {
28742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28743     return ;
28744   }
28745   arg2 = *argp2;
28746   {
28747     try {
28748       (arg1)->SetFrameBuffer(arg2);
28749     } catch (std::out_of_range& e) {
28750       {
28751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28752       };
28753     } catch (std::exception& e) {
28754       {
28755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (Dali::DaliException e) {
28758       {
28759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28760       };
28761     } catch (...) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28764       };
28765     }
28766   }
28767
28768 }
28769
28770
28771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28772   void * jresult ;
28773   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28774   Dali::FrameBuffer result;
28775
28776   arg1 = (Dali::RenderTask *)jarg1;
28777   {
28778     try {
28779       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28780     } catch (std::out_of_range& e) {
28781       {
28782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28783       };
28784     } catch (std::exception& e) {
28785       {
28786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (Dali::DaliException e) {
28789       {
28790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28791       };
28792     } catch (...) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28795       };
28796     }
28797   }
28798
28799   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28800   return jresult;
28801 }
28802
28803
28804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28805   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28806   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28807
28808   arg1 = (Dali::RenderTask *)jarg1;
28809   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28810   {
28811     try {
28812       (arg1)->SetScreenToFrameBufferFunction(arg2);
28813     } catch (std::out_of_range& e) {
28814       {
28815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28816       };
28817     } catch (std::exception& e) {
28818       {
28819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28820       };
28821     } catch (Dali::DaliException e) {
28822       {
28823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28824       };
28825     } catch (...) {
28826       {
28827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28828       };
28829     }
28830   }
28831
28832 }
28833
28834
28835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28836   void * jresult ;
28837   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28838   Dali::RenderTask::ScreenToFrameBufferFunction result;
28839
28840   arg1 = (Dali::RenderTask *)jarg1;
28841   {
28842     try {
28843       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28844     } catch (std::out_of_range& e) {
28845       {
28846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28847       };
28848     } catch (std::exception& e) {
28849       {
28850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28851       };
28852     } catch (Dali::DaliException e) {
28853       {
28854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28855       };
28856     } catch (...) {
28857       {
28858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28859       };
28860     }
28861   }
28862
28863   jresult = (void *)result;
28864   return jresult;
28865 }
28866
28867
28868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28869   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28870   Dali::Actor arg2 ;
28871   Dali::Actor *argp2 ;
28872
28873   arg1 = (Dali::RenderTask *)jarg1;
28874   argp2 = (Dali::Actor *)jarg2;
28875   if (!argp2) {
28876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28877     return ;
28878   }
28879   arg2 = *argp2;
28880   {
28881     try {
28882       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28883     } catch (std::out_of_range& e) {
28884       {
28885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28886       };
28887     } catch (std::exception& e) {
28888       {
28889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28890       };
28891     } catch (Dali::DaliException e) {
28892       {
28893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28894       };
28895     } catch (...) {
28896       {
28897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28898       };
28899     }
28900   }
28901
28902 }
28903
28904
28905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28906   void * jresult ;
28907   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28908   Dali::Actor result;
28909
28910   arg1 = (Dali::RenderTask *)jarg1;
28911   {
28912     try {
28913       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28914     } catch (std::out_of_range& e) {
28915       {
28916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28917       };
28918     } catch (std::exception& e) {
28919       {
28920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28921       };
28922     } catch (Dali::DaliException e) {
28923       {
28924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28925       };
28926     } catch (...) {
28927       {
28928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28929       };
28930     }
28931   }
28932
28933   jresult = new Dali::Actor((const Dali::Actor &)result);
28934   return jresult;
28935 }
28936
28937
28938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28939   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28940   Dali::Vector2 arg2 ;
28941   Dali::Vector2 *argp2 ;
28942
28943   arg1 = (Dali::RenderTask *)jarg1;
28944   argp2 = (Dali::Vector2 *)jarg2;
28945   if (!argp2) {
28946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28947     return ;
28948   }
28949   arg2 = *argp2;
28950   {
28951     try {
28952       (arg1)->SetViewportPosition(arg2);
28953     } catch (std::out_of_range& e) {
28954       {
28955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28956       };
28957     } catch (std::exception& e) {
28958       {
28959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28960       };
28961     } catch (Dali::DaliException e) {
28962       {
28963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28964       };
28965     } catch (...) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28968       };
28969     }
28970   }
28971
28972 }
28973
28974
28975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28976   void * jresult ;
28977   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28978   Dali::Vector2 result;
28979
28980   arg1 = (Dali::RenderTask *)jarg1;
28981   {
28982     try {
28983       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28984     } catch (std::out_of_range& e) {
28985       {
28986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28987       };
28988     } catch (std::exception& e) {
28989       {
28990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28991       };
28992     } catch (Dali::DaliException e) {
28993       {
28994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28995       };
28996     } catch (...) {
28997       {
28998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28999       };
29000     }
29001   }
29002
29003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29004   return jresult;
29005 }
29006
29007
29008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29009   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29010   Dali::Vector2 arg2 ;
29011   Dali::Vector2 *argp2 ;
29012
29013   arg1 = (Dali::RenderTask *)jarg1;
29014   argp2 = (Dali::Vector2 *)jarg2;
29015   if (!argp2) {
29016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29017     return ;
29018   }
29019   arg2 = *argp2;
29020   {
29021     try {
29022       (arg1)->SetViewportSize(arg2);
29023     } catch (std::out_of_range& e) {
29024       {
29025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (std::exception& e) {
29028       {
29029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29030       };
29031     } catch (Dali::DaliException e) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29034       };
29035     } catch (...) {
29036       {
29037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29038       };
29039     }
29040   }
29041
29042 }
29043
29044
29045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29046   void * jresult ;
29047   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29048   Dali::Vector2 result;
29049
29050   arg1 = (Dali::RenderTask *)jarg1;
29051   {
29052     try {
29053       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29054     } catch (std::out_of_range& e) {
29055       {
29056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (std::exception& e) {
29059       {
29060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29061       };
29062     } catch (Dali::DaliException e) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29065       };
29066     } catch (...) {
29067       {
29068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29069       };
29070     }
29071   }
29072
29073   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29074   return jresult;
29075 }
29076
29077
29078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29079   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29080   Dali::Viewport arg2 ;
29081   Dali::Viewport *argp2 ;
29082
29083   arg1 = (Dali::RenderTask *)jarg1;
29084   argp2 = (Dali::Viewport *)jarg2;
29085   if (!argp2) {
29086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29087     return ;
29088   }
29089   arg2 = *argp2;
29090   {
29091     try {
29092       (arg1)->SetViewport(arg2);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29100       };
29101     } catch (Dali::DaliException e) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29104       };
29105     } catch (...) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29108       };
29109     }
29110   }
29111
29112 }
29113
29114
29115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29116   void * jresult ;
29117   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29118   Dali::Viewport result;
29119
29120   arg1 = (Dali::RenderTask *)jarg1;
29121   {
29122     try {
29123       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29124     } catch (std::out_of_range& e) {
29125       {
29126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29127       };
29128     } catch (std::exception& e) {
29129       {
29130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29131       };
29132     } catch (Dali::DaliException e) {
29133       {
29134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29135       };
29136     } catch (...) {
29137       {
29138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29139       };
29140     }
29141   }
29142
29143   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29144   return jresult;
29145 }
29146
29147
29148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29149   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29150   Dali::Vector4 *arg2 = 0 ;
29151
29152   arg1 = (Dali::RenderTask *)jarg1;
29153   arg2 = (Dali::Vector4 *)jarg2;
29154   if (!arg2) {
29155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29156     return ;
29157   }
29158   {
29159     try {
29160       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29161     } catch (std::out_of_range& e) {
29162       {
29163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29164       };
29165     } catch (std::exception& e) {
29166       {
29167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (Dali::DaliException e) {
29170       {
29171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29172       };
29173     } catch (...) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29176       };
29177     }
29178   }
29179
29180 }
29181
29182
29183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29184   void * jresult ;
29185   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29186   Dali::Vector4 result;
29187
29188   arg1 = (Dali::RenderTask *)jarg1;
29189   {
29190     try {
29191       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29192     } catch (std::out_of_range& e) {
29193       {
29194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (std::exception& e) {
29197       {
29198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (Dali::DaliException e) {
29201       {
29202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29203       };
29204     } catch (...) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29207       };
29208     }
29209   }
29210
29211   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29212   return jresult;
29213 }
29214
29215
29216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29217   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29218   bool arg2 ;
29219
29220   arg1 = (Dali::RenderTask *)jarg1;
29221   arg2 = jarg2 ? true : false;
29222   {
29223     try {
29224       (arg1)->SetClearEnabled(arg2);
29225     } catch (std::out_of_range& e) {
29226       {
29227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29228       };
29229     } catch (std::exception& e) {
29230       {
29231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (Dali::DaliException e) {
29234       {
29235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29236       };
29237     } catch (...) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29240       };
29241     }
29242   }
29243
29244 }
29245
29246
29247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29248   unsigned int jresult ;
29249   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29250   bool result;
29251
29252   arg1 = (Dali::RenderTask *)jarg1;
29253   {
29254     try {
29255       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (Dali::DaliException e) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29267       };
29268     } catch (...) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29271       };
29272     }
29273   }
29274
29275   jresult = result;
29276   return jresult;
29277 }
29278
29279
29280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29281   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29282   bool arg2 ;
29283
29284   arg1 = (Dali::RenderTask *)jarg1;
29285   arg2 = jarg2 ? true : false;
29286   {
29287     try {
29288       (arg1)->SetCullMode(arg2);
29289     } catch (std::out_of_range& e) {
29290       {
29291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29292       };
29293     } catch (std::exception& e) {
29294       {
29295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (Dali::DaliException e) {
29298       {
29299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29300       };
29301     } catch (...) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29304       };
29305     }
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29312   unsigned int jresult ;
29313   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29314   bool result;
29315
29316   arg1 = (Dali::RenderTask *)jarg1;
29317   {
29318     try {
29319       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29320     } catch (std::out_of_range& e) {
29321       {
29322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29323       };
29324     } catch (std::exception& e) {
29325       {
29326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (Dali::DaliException e) {
29329       {
29330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338
29339   jresult = result;
29340   return jresult;
29341 }
29342
29343
29344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29345   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29346   unsigned int arg2 ;
29347
29348   arg1 = (Dali::RenderTask *)jarg1;
29349   arg2 = (unsigned int)jarg2;
29350   {
29351     try {
29352       (arg1)->SetRefreshRate(arg2);
29353     } catch (std::out_of_range& e) {
29354       {
29355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29356       };
29357     } catch (std::exception& e) {
29358       {
29359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (Dali::DaliException e) {
29362       {
29363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371
29372 }
29373
29374
29375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29376   unsigned int jresult ;
29377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29378   unsigned int result;
29379
29380   arg1 = (Dali::RenderTask *)jarg1;
29381   {
29382     try {
29383       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29384     } catch (std::out_of_range& e) {
29385       {
29386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (std::exception& e) {
29389       {
29390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29391       };
29392     } catch (Dali::DaliException e) {
29393       {
29394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29395       };
29396     } catch (...) {
29397       {
29398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29399       };
29400     }
29401   }
29402
29403   jresult = result;
29404   return jresult;
29405 }
29406
29407
29408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29409   unsigned int jresult ;
29410   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29411   Dali::Vector3 *arg2 = 0 ;
29412   float *arg3 = 0 ;
29413   float *arg4 = 0 ;
29414   bool result;
29415
29416   arg1 = (Dali::RenderTask *)jarg1;
29417   arg2 = (Dali::Vector3 *)jarg2;
29418   if (!arg2) {
29419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29420     return 0;
29421   }
29422   arg3 = (float *)jarg3;
29423   arg4 = (float *)jarg4;
29424   {
29425     try {
29426       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29427     } catch (std::out_of_range& e) {
29428       {
29429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29430       };
29431     } catch (std::exception& e) {
29432       {
29433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (Dali::DaliException e) {
29436       {
29437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29438       };
29439     } catch (...) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29442       };
29443     }
29444   }
29445
29446   jresult = result;
29447   return jresult;
29448 }
29449
29450
29451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29452   unsigned int jresult ;
29453   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29454   Dali::Actor arg2 ;
29455   float arg3 ;
29456   float arg4 ;
29457   float *arg5 = 0 ;
29458   float *arg6 = 0 ;
29459   Dali::Actor *argp2 ;
29460   bool result;
29461
29462   arg1 = (Dali::RenderTask *)jarg1;
29463   argp2 = (Dali::Actor *)jarg2;
29464   if (!argp2) {
29465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29466     return 0;
29467   }
29468   arg2 = *argp2;
29469   arg3 = (float)jarg3;
29470   arg4 = (float)jarg4;
29471   arg5 = (float *)jarg5;
29472   arg6 = (float *)jarg6;
29473   {
29474     try {
29475       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29476     } catch (std::out_of_range& e) {
29477       {
29478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29479       };
29480     } catch (std::exception& e) {
29481       {
29482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29483       };
29484     } catch (Dali::DaliException e) {
29485       {
29486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29487       };
29488     } catch (...) {
29489       {
29490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29491       };
29492     }
29493   }
29494
29495   jresult = result;
29496   return jresult;
29497 }
29498
29499
29500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29501   void * jresult ;
29502   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29503   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29504
29505   arg1 = (Dali::RenderTask *)jarg1;
29506   {
29507     try {
29508       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29509     } catch (std::out_of_range& e) {
29510       {
29511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29512       };
29513     } catch (std::exception& e) {
29514       {
29515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29516       };
29517     } catch (Dali::DaliException e) {
29518       {
29519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29520       };
29521     } catch (...) {
29522       {
29523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29524       };
29525     }
29526   }
29527
29528   jresult = (void *)result;
29529   return jresult;
29530 }
29531
29532
29533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29534   void * jresult ;
29535   int arg1 ;
29536   Dali::TouchPoint::State arg2 ;
29537   float arg3 ;
29538   float arg4 ;
29539   Dali::TouchPoint *result = 0 ;
29540
29541   arg1 = (int)jarg1;
29542   arg2 = (Dali::TouchPoint::State)jarg2;
29543   arg3 = (float)jarg3;
29544   arg4 = (float)jarg4;
29545   {
29546     try {
29547       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29548     } catch (std::out_of_range& e) {
29549       {
29550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29551       };
29552     } catch (std::exception& e) {
29553       {
29554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29555       };
29556     } catch (Dali::DaliException e) {
29557       {
29558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29559       };
29560     } catch (...) {
29561       {
29562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29563       };
29564     }
29565   }
29566
29567   jresult = (void *)result;
29568   return jresult;
29569 }
29570
29571
29572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29573   void * jresult ;
29574   int arg1 ;
29575   Dali::TouchPoint::State arg2 ;
29576   float arg3 ;
29577   float arg4 ;
29578   float arg5 ;
29579   float arg6 ;
29580   Dali::TouchPoint *result = 0 ;
29581
29582   arg1 = (int)jarg1;
29583   arg2 = (Dali::TouchPoint::State)jarg2;
29584   arg3 = (float)jarg3;
29585   arg4 = (float)jarg4;
29586   arg5 = (float)jarg5;
29587   arg6 = (float)jarg6;
29588   {
29589     try {
29590       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29591     } catch (std::out_of_range& e) {
29592       {
29593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29594       };
29595     } catch (std::exception& e) {
29596       {
29597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29598       };
29599     } catch (Dali::DaliException e) {
29600       {
29601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29602       };
29603     } catch (...) {
29604       {
29605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29606       };
29607     }
29608   }
29609
29610   jresult = (void *)result;
29611   return jresult;
29612 }
29613
29614
29615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29616   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29617
29618   arg1 = (Dali::TouchPoint *)jarg1;
29619   {
29620     try {
29621       delete arg1;
29622     } catch (std::out_of_range& e) {
29623       {
29624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29625       };
29626     } catch (std::exception& e) {
29627       {
29628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29629       };
29630     } catch (Dali::DaliException e) {
29631       {
29632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29633       };
29634     } catch (...) {
29635       {
29636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29637       };
29638     }
29639   }
29640
29641 }
29642
29643
29644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29645   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29646   int arg2 ;
29647
29648   arg1 = (Dali::TouchPoint *)jarg1;
29649   arg2 = (int)jarg2;
29650   if (arg1) (arg1)->deviceId = arg2;
29651 }
29652
29653
29654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29655   int jresult ;
29656   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29657   int result;
29658
29659   arg1 = (Dali::TouchPoint *)jarg1;
29660   result = (int) ((arg1)->deviceId);
29661   jresult = result;
29662   return jresult;
29663 }
29664
29665
29666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29667   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29668   Dali::TouchPoint::State arg2 ;
29669
29670   arg1 = (Dali::TouchPoint *)jarg1;
29671   arg2 = (Dali::TouchPoint::State)jarg2;
29672   if (arg1) (arg1)->state = arg2;
29673 }
29674
29675
29676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29677   int jresult ;
29678   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29679   Dali::TouchPoint::State result;
29680
29681   arg1 = (Dali::TouchPoint *)jarg1;
29682   result = (Dali::TouchPoint::State) ((arg1)->state);
29683   jresult = (int)result;
29684   return jresult;
29685 }
29686
29687
29688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29689   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29690   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29691
29692   arg1 = (Dali::TouchPoint *)jarg1;
29693   arg2 = (Dali::Actor *)jarg2;
29694   if (arg1) (arg1)->hitActor = *arg2;
29695 }
29696
29697
29698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29699   void * jresult ;
29700   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29701   Dali::Actor *result = 0 ;
29702
29703   arg1 = (Dali::TouchPoint *)jarg1;
29704   result = (Dali::Actor *)& ((arg1)->hitActor);
29705   jresult = (void *)result;
29706   return jresult;
29707 }
29708
29709
29710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29711   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29712   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29713
29714   arg1 = (Dali::TouchPoint *)jarg1;
29715   arg2 = (Dali::Vector2 *)jarg2;
29716   if (arg1) (arg1)->local = *arg2;
29717 }
29718
29719
29720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29721   void * jresult ;
29722   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29723   Dali::Vector2 *result = 0 ;
29724
29725   arg1 = (Dali::TouchPoint *)jarg1;
29726   result = (Dali::Vector2 *)& ((arg1)->local);
29727   jresult = (void *)result;
29728   return jresult;
29729 }
29730
29731
29732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29733   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29734   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29735
29736   arg1 = (Dali::TouchPoint *)jarg1;
29737   arg2 = (Dali::Vector2 *)jarg2;
29738   if (arg1) (arg1)->screen = *arg2;
29739 }
29740
29741
29742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29743   void * jresult ;
29744   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29745   Dali::Vector2 *result = 0 ;
29746
29747   arg1 = (Dali::TouchPoint *)jarg1;
29748   result = (Dali::Vector2 *)& ((arg1)->screen);
29749   jresult = (void *)result;
29750   return jresult;
29751 }
29752
29753
29754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29755   void * jresult ;
29756   Dali::TouchData *result = 0 ;
29757
29758   {
29759     try {
29760       result = (Dali::TouchData *)new Dali::TouchData();
29761     } catch (std::out_of_range& e) {
29762       {
29763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29764       };
29765     } catch (std::exception& e) {
29766       {
29767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29768       };
29769     } catch (Dali::DaliException e) {
29770       {
29771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29772       };
29773     } catch (...) {
29774       {
29775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29776       };
29777     }
29778   }
29779
29780   jresult = (void *)result;
29781   return jresult;
29782 }
29783
29784
29785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29786   void * jresult ;
29787   Dali::TouchData *arg1 = 0 ;
29788   Dali::TouchData *result = 0 ;
29789
29790   arg1 = (Dali::TouchData *)jarg1;
29791   if (!arg1) {
29792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29793     return 0;
29794   }
29795   {
29796     try {
29797       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29798     } catch (std::out_of_range& e) {
29799       {
29800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29801       };
29802     } catch (std::exception& e) {
29803       {
29804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29805       };
29806     } catch (Dali::DaliException e) {
29807       {
29808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29809       };
29810     } catch (...) {
29811       {
29812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29813       };
29814     }
29815   }
29816
29817   jresult = (void *)result;
29818   return jresult;
29819 }
29820
29821
29822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29823   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29824
29825   arg1 = (Dali::TouchData *)jarg1;
29826   {
29827     try {
29828       delete arg1;
29829     } catch (std::out_of_range& e) {
29830       {
29831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29832       };
29833     } catch (std::exception& e) {
29834       {
29835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29836       };
29837     } catch (Dali::DaliException e) {
29838       {
29839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29840       };
29841     } catch (...) {
29842       {
29843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29844       };
29845     }
29846   }
29847
29848 }
29849
29850
29851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29852   void * jresult ;
29853   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29854   Dali::TouchData *arg2 = 0 ;
29855   Dali::TouchData *result = 0 ;
29856
29857   arg1 = (Dali::TouchData *)jarg1;
29858   arg2 = (Dali::TouchData *)jarg2;
29859   if (!arg2) {
29860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29861     return 0;
29862   }
29863   {
29864     try {
29865       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29866     } catch (std::out_of_range& e) {
29867       {
29868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29869       };
29870     } catch (std::exception& e) {
29871       {
29872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29873       };
29874     } catch (Dali::DaliException e) {
29875       {
29876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29877       };
29878     } catch (...) {
29879       {
29880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29881       };
29882     }
29883   }
29884
29885   jresult = (void *)result;
29886   return jresult;
29887 }
29888
29889
29890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29891   unsigned long jresult ;
29892   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29893   unsigned long result;
29894
29895   arg1 = (Dali::TouchData *)jarg1;
29896   {
29897     try {
29898       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29899     } catch (std::out_of_range& e) {
29900       {
29901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29902       };
29903     } catch (std::exception& e) {
29904       {
29905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29906       };
29907     } catch (Dali::DaliException e) {
29908       {
29909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29910       };
29911     } catch (...) {
29912       {
29913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29914       };
29915     }
29916   }
29917
29918   jresult = (unsigned long)result;
29919   return jresult;
29920 }
29921
29922
29923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29924   unsigned long jresult ;
29925   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29926   std::size_t result;
29927
29928   arg1 = (Dali::TouchData *)jarg1;
29929   {
29930     try {
29931       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29932     } catch (std::out_of_range& e) {
29933       {
29934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29935       };
29936     } catch (std::exception& e) {
29937       {
29938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29939       };
29940     } catch (Dali::DaliException e) {
29941       {
29942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29943       };
29944     } catch (...) {
29945       {
29946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29947       };
29948     }
29949   }
29950
29951   jresult = (unsigned long)result;
29952   return jresult;
29953 }
29954
29955
29956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29957   int jresult ;
29958   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29959   std::size_t arg2 ;
29960   int32_t result;
29961
29962   arg1 = (Dali::TouchData *)jarg1;
29963   arg2 = (std::size_t)jarg2;
29964   {
29965     try {
29966       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29967     } catch (std::out_of_range& e) {
29968       {
29969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29970       };
29971     } catch (std::exception& e) {
29972       {
29973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29974       };
29975     } catch (Dali::DaliException e) {
29976       {
29977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29978       };
29979     } catch (...) {
29980       {
29981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29982       };
29983     }
29984   }
29985
29986   jresult = result;
29987   return jresult;
29988 }
29989
29990
29991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29992   int jresult ;
29993   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29994   std::size_t arg2 ;
29995   Dali::PointState::Type result;
29996
29997   arg1 = (Dali::TouchData *)jarg1;
29998   arg2 = (std::size_t)jarg2;
29999   {
30000     try {
30001       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30002     } catch (std::out_of_range& e) {
30003       {
30004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30005       };
30006     } catch (std::exception& e) {
30007       {
30008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30009       };
30010     } catch (Dali::DaliException e) {
30011       {
30012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30013       };
30014     } catch (...) {
30015       {
30016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30017       };
30018     }
30019   }
30020
30021   jresult = (int)result;
30022   return jresult;
30023 }
30024
30025
30026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30027   void * jresult ;
30028   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30029   std::size_t arg2 ;
30030   Dali::Actor result;
30031
30032   arg1 = (Dali::TouchData *)jarg1;
30033   arg2 = (std::size_t)jarg2;
30034   {
30035     try {
30036       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30037     } catch (std::out_of_range& e) {
30038       {
30039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30040       };
30041     } catch (std::exception& e) {
30042       {
30043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30044       };
30045     } catch (Dali::DaliException e) {
30046       {
30047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30048       };
30049     } catch (...) {
30050       {
30051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30052       };
30053     }
30054   }
30055
30056   jresult = new Dali::Actor((const Dali::Actor &)result);
30057   return jresult;
30058 }
30059
30060
30061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30062   void * jresult ;
30063   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30064   std::size_t arg2 ;
30065   Dali::Vector2 *result = 0 ;
30066
30067   arg1 = (Dali::TouchData *)jarg1;
30068   arg2 = (std::size_t)jarg2;
30069   {
30070     try {
30071       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30072     } catch (std::out_of_range& e) {
30073       {
30074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30075       };
30076     } catch (std::exception& e) {
30077       {
30078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30079       };
30080     } catch (Dali::DaliException e) {
30081       {
30082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30083       };
30084     } catch (...) {
30085       {
30086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30087       };
30088     }
30089   }
30090
30091   jresult = (void *)result;
30092   return jresult;
30093 }
30094
30095
30096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30097   void * jresult ;
30098   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30099   std::size_t arg2 ;
30100   Dali::Vector2 *result = 0 ;
30101
30102   arg1 = (Dali::TouchData *)jarg1;
30103   arg2 = (std::size_t)jarg2;
30104   {
30105     try {
30106       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30107     } catch (std::out_of_range& e) {
30108       {
30109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30110       };
30111     } catch (std::exception& e) {
30112       {
30113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30114       };
30115     } catch (Dali::DaliException e) {
30116       {
30117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30118       };
30119     } catch (...) {
30120       {
30121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30122       };
30123     }
30124   }
30125
30126   jresult = (void *)result;
30127   return jresult;
30128 }
30129
30130
30131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30132   float jresult ;
30133   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30134   std::size_t arg2 ;
30135   float result;
30136
30137   arg1 = (Dali::TouchData *)jarg1;
30138   arg2 = (std::size_t)jarg2;
30139   {
30140     try {
30141       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30142     } catch (std::out_of_range& e) {
30143       {
30144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30145       };
30146     } catch (std::exception& e) {
30147       {
30148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30149       };
30150     } catch (Dali::DaliException e) {
30151       {
30152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30153       };
30154     } catch (...) {
30155       {
30156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30157       };
30158     }
30159   }
30160
30161   jresult = result;
30162   return jresult;
30163 }
30164
30165
30166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30167   void * jresult ;
30168   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30169   std::size_t arg2 ;
30170   Dali::Vector2 *result = 0 ;
30171
30172   arg1 = (Dali::TouchData *)jarg1;
30173   arg2 = (std::size_t)jarg2;
30174   {
30175     try {
30176       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30177     } catch (std::out_of_range& e) {
30178       {
30179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30180       };
30181     } catch (std::exception& e) {
30182       {
30183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30184       };
30185     } catch (Dali::DaliException e) {
30186       {
30187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30188       };
30189     } catch (...) {
30190       {
30191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30192       };
30193     }
30194   }
30195
30196   jresult = (void *)result;
30197   return jresult;
30198 }
30199
30200
30201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30202   float jresult ;
30203   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30204   std::size_t arg2 ;
30205   float result;
30206
30207   arg1 = (Dali::TouchData *)jarg1;
30208   arg2 = (std::size_t)jarg2;
30209   {
30210     try {
30211       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30212     } catch (std::out_of_range& e) {
30213       {
30214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30215       };
30216     } catch (std::exception& e) {
30217       {
30218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30219       };
30220     } catch (Dali::DaliException e) {
30221       {
30222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30223       };
30224     } catch (...) {
30225       {
30226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30227       };
30228     }
30229   }
30230
30231   jresult = result;
30232   return jresult;
30233 }
30234
30235
30236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30237   void * jresult ;
30238   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30239   std::size_t arg2 ;
30240   Dali::Degree result;
30241
30242   arg1 = (Dali::TouchData *)jarg1;
30243   arg2 = (std::size_t)jarg2;
30244   {
30245     try {
30246       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30247     } catch (std::out_of_range& e) {
30248       {
30249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30250       };
30251     } catch (std::exception& e) {
30252       {
30253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30254       };
30255     } catch (Dali::DaliException e) {
30256       {
30257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30258       };
30259     } catch (...) {
30260       {
30261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30262       };
30263     }
30264   }
30265
30266   jresult = new Dali::Degree((const Dali::Degree &)result);
30267   return jresult;
30268 }
30269
30270
30271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30272   void * jresult ;
30273   Dali::GestureDetector *result = 0 ;
30274
30275   {
30276     try {
30277       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30278     } catch (std::out_of_range& e) {
30279       {
30280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30281       };
30282     } catch (std::exception& e) {
30283       {
30284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30285       };
30286     } catch (Dali::DaliException e) {
30287       {
30288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30289       };
30290     } catch (...) {
30291       {
30292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30293       };
30294     }
30295   }
30296
30297   jresult = (void *)result;
30298   return jresult;
30299 }
30300
30301
30302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30303   void * jresult ;
30304   Dali::BaseHandle arg1 ;
30305   Dali::BaseHandle *argp1 ;
30306   Dali::GestureDetector result;
30307
30308   argp1 = (Dali::BaseHandle *)jarg1;
30309   if (!argp1) {
30310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30311     return 0;
30312   }
30313   arg1 = *argp1;
30314   {
30315     try {
30316       result = Dali::GestureDetector::DownCast(arg1);
30317     } catch (std::out_of_range& e) {
30318       {
30319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30320       };
30321     } catch (std::exception& e) {
30322       {
30323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30324       };
30325     } catch (Dali::DaliException e) {
30326       {
30327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30328       };
30329     } catch (...) {
30330       {
30331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30332       };
30333     }
30334   }
30335
30336   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30337   return jresult;
30338 }
30339
30340
30341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30342   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30343
30344   arg1 = (Dali::GestureDetector *)jarg1;
30345   {
30346     try {
30347       delete arg1;
30348     } catch (std::out_of_range& e) {
30349       {
30350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30351       };
30352     } catch (std::exception& e) {
30353       {
30354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30355       };
30356     } catch (Dali::DaliException e) {
30357       {
30358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30359       };
30360     } catch (...) {
30361       {
30362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30363       };
30364     }
30365   }
30366
30367 }
30368
30369
30370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30371   void * jresult ;
30372   Dali::GestureDetector *arg1 = 0 ;
30373   Dali::GestureDetector *result = 0 ;
30374
30375   arg1 = (Dali::GestureDetector *)jarg1;
30376   if (!arg1) {
30377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30378     return 0;
30379   }
30380   {
30381     try {
30382       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30383     } catch (std::out_of_range& e) {
30384       {
30385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30386       };
30387     } catch (std::exception& e) {
30388       {
30389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30390       };
30391     } catch (Dali::DaliException e) {
30392       {
30393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30394       };
30395     } catch (...) {
30396       {
30397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30398       };
30399     }
30400   }
30401
30402   jresult = (void *)result;
30403   return jresult;
30404 }
30405
30406
30407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30408   void * jresult ;
30409   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30410   Dali::GestureDetector *arg2 = 0 ;
30411   Dali::GestureDetector *result = 0 ;
30412
30413   arg1 = (Dali::GestureDetector *)jarg1;
30414   arg2 = (Dali::GestureDetector *)jarg2;
30415   if (!arg2) {
30416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30417     return 0;
30418   }
30419   {
30420     try {
30421       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30422     } catch (std::out_of_range& e) {
30423       {
30424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30425       };
30426     } catch (std::exception& e) {
30427       {
30428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30429       };
30430     } catch (Dali::DaliException e) {
30431       {
30432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30433       };
30434     } catch (...) {
30435       {
30436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30437       };
30438     }
30439   }
30440
30441   jresult = (void *)result;
30442   return jresult;
30443 }
30444
30445
30446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30447   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30448   Dali::Actor arg2 ;
30449   Dali::Actor *argp2 ;
30450
30451   arg1 = (Dali::GestureDetector *)jarg1;
30452   argp2 = (Dali::Actor *)jarg2;
30453   if (!argp2) {
30454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30455     return ;
30456   }
30457   arg2 = *argp2;
30458   {
30459     try {
30460       (arg1)->Attach(arg2);
30461     } catch (std::out_of_range& e) {
30462       {
30463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30464       };
30465     } catch (std::exception& e) {
30466       {
30467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30468       };
30469     } catch (Dali::DaliException e) {
30470       {
30471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30472       };
30473     } catch (...) {
30474       {
30475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30476       };
30477     }
30478   }
30479
30480 }
30481
30482
30483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30484   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30485   Dali::Actor arg2 ;
30486   Dali::Actor *argp2 ;
30487
30488   arg1 = (Dali::GestureDetector *)jarg1;
30489   argp2 = (Dali::Actor *)jarg2;
30490   if (!argp2) {
30491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30492     return ;
30493   }
30494   arg2 = *argp2;
30495   {
30496     try {
30497       (arg1)->Detach(arg2);
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30513       };
30514     }
30515   }
30516
30517 }
30518
30519
30520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30521   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30522
30523   arg1 = (Dali::GestureDetector *)jarg1;
30524   {
30525     try {
30526       (arg1)->DetachAll();
30527     } catch (std::out_of_range& e) {
30528       {
30529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30530       };
30531     } catch (std::exception& e) {
30532       {
30533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30534       };
30535     } catch (Dali::DaliException e) {
30536       {
30537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30538       };
30539     } catch (...) {
30540       {
30541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30542       };
30543     }
30544   }
30545
30546 }
30547
30548
30549 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30550   unsigned long jresult ;
30551   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30552   size_t result;
30553
30554   arg1 = (Dali::GestureDetector *)jarg1;
30555   {
30556     try {
30557       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30558     } catch (std::out_of_range& e) {
30559       {
30560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30561       };
30562     } catch (std::exception& e) {
30563       {
30564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30565       };
30566     } catch (Dali::DaliException e) {
30567       {
30568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30569       };
30570     } catch (...) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30573       };
30574     }
30575   }
30576
30577   jresult = (unsigned long)result;
30578   return jresult;
30579 }
30580
30581
30582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30583   void * jresult ;
30584   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30585   size_t arg2 ;
30586   Dali::Actor result;
30587
30588   arg1 = (Dali::GestureDetector *)jarg1;
30589   arg2 = (size_t)jarg2;
30590   {
30591     try {
30592       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30593     } catch (std::out_of_range& e) {
30594       {
30595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30596       };
30597     } catch (std::exception& e) {
30598       {
30599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30600       };
30601     } catch (Dali::DaliException e) {
30602       {
30603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30604       };
30605     } catch (...) {
30606       {
30607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30608       };
30609     }
30610   }
30611
30612   jresult = new Dali::Actor((const Dali::Actor &)result);
30613   return jresult;
30614 }
30615
30616
30617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30618   void * jresult ;
30619   Dali::Gesture *arg1 = 0 ;
30620   Dali::Gesture *result = 0 ;
30621
30622   arg1 = (Dali::Gesture *)jarg1;
30623   if (!arg1) {
30624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30625     return 0;
30626   }
30627   {
30628     try {
30629       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30630     } catch (std::out_of_range& e) {
30631       {
30632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30633       };
30634     } catch (std::exception& e) {
30635       {
30636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30637       };
30638     } catch (Dali::DaliException e) {
30639       {
30640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30641       };
30642     } catch (...) {
30643       {
30644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30645       };
30646     }
30647   }
30648
30649   jresult = (void *)result;
30650   return jresult;
30651 }
30652
30653
30654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30655   void * jresult ;
30656   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30657   Dali::Gesture *arg2 = 0 ;
30658   Dali::Gesture *result = 0 ;
30659
30660   arg1 = (Dali::Gesture *)jarg1;
30661   arg2 = (Dali::Gesture *)jarg2;
30662   if (!arg2) {
30663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30664     return 0;
30665   }
30666   {
30667     try {
30668       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (Dali::DaliException e) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30680       };
30681     } catch (...) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30684       };
30685     }
30686   }
30687
30688   jresult = (void *)result;
30689   return jresult;
30690 }
30691
30692
30693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30694   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30695
30696   arg1 = (Dali::Gesture *)jarg1;
30697   {
30698     try {
30699       delete arg1;
30700     } catch (std::out_of_range& e) {
30701       {
30702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30703       };
30704     } catch (std::exception& e) {
30705       {
30706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30707       };
30708     } catch (Dali::DaliException e) {
30709       {
30710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30711       };
30712     } catch (...) {
30713       {
30714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30715       };
30716     }
30717   }
30718
30719 }
30720
30721
30722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30723   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30724   Dali::Gesture::Type arg2 ;
30725
30726   arg1 = (Dali::Gesture *)jarg1;
30727   arg2 = (Dali::Gesture::Type)jarg2;
30728   if (arg1) (arg1)->type = arg2;
30729 }
30730
30731
30732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30733   int jresult ;
30734   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30735   Dali::Gesture::Type result;
30736
30737   arg1 = (Dali::Gesture *)jarg1;
30738   result = (Dali::Gesture::Type) ((arg1)->type);
30739   jresult = (int)result;
30740   return jresult;
30741 }
30742
30743
30744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30745   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30746   Dali::Gesture::State arg2 ;
30747
30748   arg1 = (Dali::Gesture *)jarg1;
30749   arg2 = (Dali::Gesture::State)jarg2;
30750   if (arg1) (arg1)->state = arg2;
30751 }
30752
30753
30754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30755   int jresult ;
30756   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30757   Dali::Gesture::State result;
30758
30759   arg1 = (Dali::Gesture *)jarg1;
30760   result = (Dali::Gesture::State) ((arg1)->state);
30761   jresult = (int)result;
30762   return jresult;
30763 }
30764
30765
30766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30767   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30768   unsigned int arg2 ;
30769
30770   arg1 = (Dali::Gesture *)jarg1;
30771   arg2 = (unsigned int)jarg2;
30772   if (arg1) (arg1)->time = arg2;
30773 }
30774
30775
30776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30777   unsigned int jresult ;
30778   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30779   unsigned int result;
30780
30781   arg1 = (Dali::Gesture *)jarg1;
30782   result = (unsigned int) ((arg1)->time);
30783   jresult = result;
30784   return jresult;
30785 }
30786
30787
30788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30789   void * jresult ;
30790   Dali::HoverEvent *result = 0 ;
30791
30792   {
30793     try {
30794       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30795     } catch (std::out_of_range& e) {
30796       {
30797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30798       };
30799     } catch (std::exception& e) {
30800       {
30801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30802       };
30803     } catch (Dali::DaliException e) {
30804       {
30805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30806       };
30807     } catch (...) {
30808       {
30809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30810       };
30811     }
30812   }
30813
30814   jresult = (void *)result;
30815   return jresult;
30816 }
30817
30818
30819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30820   void * jresult ;
30821   unsigned long arg1 ;
30822   Dali::HoverEvent *result = 0 ;
30823
30824   arg1 = (unsigned long)jarg1;
30825   {
30826     try {
30827       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30828     } catch (std::out_of_range& e) {
30829       {
30830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30831       };
30832     } catch (std::exception& e) {
30833       {
30834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30835       };
30836     } catch (Dali::DaliException e) {
30837       {
30838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30839       };
30840     } catch (...) {
30841       {
30842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30843       };
30844     }
30845   }
30846
30847   jresult = (void *)result;
30848   return jresult;
30849 }
30850
30851
30852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30853   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30854
30855   arg1 = (Dali::HoverEvent *)jarg1;
30856   {
30857     try {
30858       delete arg1;
30859     } catch (std::out_of_range& e) {
30860       {
30861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30862       };
30863     } catch (std::exception& e) {
30864       {
30865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30866       };
30867     } catch (Dali::DaliException e) {
30868       {
30869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30870       };
30871     } catch (...) {
30872       {
30873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30874       };
30875     }
30876   }
30877
30878 }
30879
30880
30881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30882   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30883   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30884
30885   arg1 = (Dali::HoverEvent *)jarg1;
30886   arg2 = (Dali::TouchPointContainer *)jarg2;
30887   if (arg1) (arg1)->points = *arg2;
30888 }
30889
30890
30891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30892   void * jresult ;
30893   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30894   Dali::TouchPointContainer *result = 0 ;
30895
30896   arg1 = (Dali::HoverEvent *)jarg1;
30897   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30898   jresult = (void *)result;
30899   return jresult;
30900 }
30901
30902
30903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30904   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30905   unsigned long arg2 ;
30906
30907   arg1 = (Dali::HoverEvent *)jarg1;
30908   arg2 = (unsigned long)jarg2;
30909   if (arg1) (arg1)->time = arg2;
30910 }
30911
30912
30913 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30914   unsigned long jresult ;
30915   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30916   unsigned long result;
30917
30918   arg1 = (Dali::HoverEvent *)jarg1;
30919   result = (unsigned long) ((arg1)->time);
30920   jresult = (unsigned long)result;
30921   return jresult;
30922 }
30923
30924
30925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30926   unsigned int jresult ;
30927   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30928   unsigned int result;
30929
30930   arg1 = (Dali::HoverEvent *)jarg1;
30931   {
30932     try {
30933       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30934     } catch (std::out_of_range& e) {
30935       {
30936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (std::exception& e) {
30939       {
30940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30941       };
30942     } catch (Dali::DaliException e) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30945       };
30946     } catch (...) {
30947       {
30948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30949       };
30950     }
30951   }
30952
30953   jresult = result;
30954   return jresult;
30955 }
30956
30957
30958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30959   void * jresult ;
30960   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30961   unsigned int arg2 ;
30962   Dali::TouchPoint *result = 0 ;
30963
30964   arg1 = (Dali::HoverEvent *)jarg1;
30965   arg2 = (unsigned int)jarg2;
30966   {
30967     try {
30968       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30969     } catch (std::out_of_range& e) {
30970       {
30971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30972       };
30973     } catch (std::exception& e) {
30974       {
30975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30976       };
30977     } catch (Dali::DaliException e) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30980       };
30981     } catch (...) {
30982       {
30983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30984       };
30985     }
30986   }
30987
30988   jresult = (void *)result;
30989   return jresult;
30990 }
30991
30992
30993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30994   void * jresult ;
30995   Dali::KeyEvent *result = 0 ;
30996
30997   {
30998     try {
30999       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31000     } catch (std::out_of_range& e) {
31001       {
31002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31003       };
31004     } catch (std::exception& e) {
31005       {
31006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31007       };
31008     } catch (Dali::DaliException e) {
31009       {
31010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31011       };
31012     } catch (...) {
31013       {
31014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31015       };
31016     }
31017   }
31018
31019   jresult = (void *)result;
31020   return jresult;
31021 }
31022
31023
31024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31025   void * jresult ;
31026   std::string *arg1 = 0 ;
31027   std::string *arg2 = 0 ;
31028   int arg3 ;
31029   int arg4 ;
31030   unsigned long arg5 ;
31031   Dali::KeyEvent::State *arg6 = 0 ;
31032   Dali::KeyEvent::State temp6 ;
31033   Dali::KeyEvent *result = 0 ;
31034
31035   if (!jarg1) {
31036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31037     return 0;
31038   }
31039   std::string arg1_str(jarg1);
31040   arg1 = &arg1_str;
31041   if (!jarg2) {
31042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31043     return 0;
31044   }
31045   std::string arg2_str(jarg2);
31046   arg2 = &arg2_str;
31047   arg3 = (int)jarg3;
31048   arg4 = (int)jarg4;
31049   arg5 = (unsigned long)jarg5;
31050   temp6 = (Dali::KeyEvent::State)jarg6;
31051   arg6 = &temp6;
31052   {
31053     try {
31054       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31055     } catch (std::out_of_range& e) {
31056       {
31057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31058       };
31059     } catch (std::exception& e) {
31060       {
31061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31062       };
31063     } catch (Dali::DaliException e) {
31064       {
31065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31066       };
31067     } catch (...) {
31068       {
31069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31070       };
31071     }
31072   }
31073
31074   jresult = (void *)result;
31075
31076   //argout typemap for const std::string&
31077
31078
31079   //argout typemap for const std::string&
31080
31081   return jresult;
31082 }
31083
31084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31085   void * jresult ;
31086   Dali::KeyEvent *arg1 = 0 ;
31087   Dali::KeyEvent *result = 0 ;
31088
31089   arg1 = (Dali::KeyEvent *)jarg1;
31090   if (!arg1) {
31091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31092     return 0;
31093   }
31094   {
31095     try {
31096       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31097     } catch (std::out_of_range& e) {
31098       {
31099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31100       };
31101     } catch (std::exception& e) {
31102       {
31103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31104       };
31105     } catch (Dali::DaliException e) {
31106       {
31107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31108       };
31109     } catch (...) {
31110       {
31111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31112       };
31113     }
31114   }
31115
31116   jresult = (void *)result;
31117   return jresult;
31118 }
31119
31120
31121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31122   void * jresult ;
31123   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31124   Dali::KeyEvent *arg2 = 0 ;
31125   Dali::KeyEvent *result = 0 ;
31126
31127   arg1 = (Dali::KeyEvent *)jarg1;
31128   arg2 = (Dali::KeyEvent *)jarg2;
31129   if (!arg2) {
31130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31131     return 0;
31132   }
31133   {
31134     try {
31135       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31136     } catch (std::out_of_range& e) {
31137       {
31138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31139       };
31140     } catch (std::exception& e) {
31141       {
31142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31143       };
31144     } catch (Dali::DaliException e) {
31145       {
31146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31147       };
31148     } catch (...) {
31149       {
31150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31151       };
31152     }
31153   }
31154
31155   jresult = (void *)result;
31156   return jresult;
31157 }
31158
31159
31160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31161   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31162
31163   arg1 = (Dali::KeyEvent *)jarg1;
31164   {
31165     try {
31166       delete arg1;
31167     } catch (std::out_of_range& e) {
31168       {
31169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31170       };
31171     } catch (std::exception& e) {
31172       {
31173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31174       };
31175     } catch (Dali::DaliException e) {
31176       {
31177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31178       };
31179     } catch (...) {
31180       {
31181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31182       };
31183     }
31184   }
31185
31186 }
31187
31188
31189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31190   unsigned int jresult ;
31191   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31192   bool result;
31193
31194   arg1 = (Dali::KeyEvent *)jarg1;
31195   {
31196     try {
31197       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31198     } catch (std::out_of_range& e) {
31199       {
31200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31201       };
31202     } catch (std::exception& e) {
31203       {
31204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31205       };
31206     } catch (Dali::DaliException e) {
31207       {
31208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31209       };
31210     } catch (...) {
31211       {
31212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31213       };
31214     }
31215   }
31216
31217   jresult = result;
31218   return jresult;
31219 }
31220
31221
31222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31223   unsigned int jresult ;
31224   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31225   bool result;
31226
31227   arg1 = (Dali::KeyEvent *)jarg1;
31228   {
31229     try {
31230       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31231     } catch (std::out_of_range& e) {
31232       {
31233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (std::exception& e) {
31236       {
31237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (Dali::DaliException e) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31242       };
31243     } catch (...) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31246       };
31247     }
31248   }
31249
31250   jresult = result;
31251   return jresult;
31252 }
31253
31254
31255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31256   unsigned int jresult ;
31257   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31258   bool result;
31259
31260   arg1 = (Dali::KeyEvent *)jarg1;
31261   {
31262     try {
31263       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31264     } catch (std::out_of_range& e) {
31265       {
31266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31267       };
31268     } catch (std::exception& e) {
31269       {
31270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31271       };
31272     } catch (Dali::DaliException e) {
31273       {
31274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31275       };
31276     } catch (...) {
31277       {
31278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31279       };
31280     }
31281   }
31282
31283   jresult = result;
31284   return jresult;
31285 }
31286
31287
31288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31289   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31290   std::string *arg2 = 0 ;
31291
31292   arg1 = (Dali::KeyEvent *)jarg1;
31293   if (!jarg2) {
31294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31295     return ;
31296   }
31297   std::string arg2_str(jarg2);
31298   arg2 = &arg2_str;
31299   if (arg1) (arg1)->keyPressedName = *arg2;
31300
31301   //argout typemap for const std::string&
31302
31303 }
31304
31305
31306 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31307   char * jresult ;
31308
31309   if( jarg1 == NULL )
31310   {
31311     jresult = SWIG_csharp_string_callback( "" );
31312   }
31313   else
31314   {
31315     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31316     std::string *result = 0;
31317
31318     arg1 = ( Dali::KeyEvent * )jarg1;
31319     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31320     jresult = SWIG_csharp_string_callback( result->c_str() );
31321   }
31322
31323   return jresult;
31324 }
31325
31326
31327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31328   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31329   std::string *arg2 = 0 ;
31330
31331   arg1 = (Dali::KeyEvent *)jarg1;
31332   if (!jarg2) {
31333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31334     return ;
31335   }
31336   std::string arg2_str(jarg2);
31337   arg2 = &arg2_str;
31338   if (arg1) (arg1)->keyPressed = *arg2;
31339
31340   //argout typemap for const std::string&
31341
31342 }
31343
31344
31345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31346   char * jresult ;
31347   if( NULL == jarg1 )
31348   {
31349     jresult = SWIG_csharp_string_callback( "" );
31350   }
31351   else
31352   {
31353     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31354     std::string *result = 0;
31355
31356     arg1 = ( Dali::KeyEvent * )jarg1;
31357     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31358     jresult = SWIG_csharp_string_callback( result->c_str() );
31359   }
31360   return jresult;
31361 }
31362
31363
31364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31365   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31366   int arg2 ;
31367
31368   arg1 = (Dali::KeyEvent *)jarg1;
31369   arg2 = (int)jarg2;
31370   if (arg1) (arg1)->keyCode = arg2;
31371 }
31372
31373
31374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31375   int jresult ;
31376   if( NULL == jarg1 )
31377   {
31378     jresult = -1;
31379   }
31380   else
31381   {
31382     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31383     int result;
31384
31385     arg1 = ( Dali::KeyEvent * )jarg1;
31386     result = (int)( ( arg1 )->keyCode );
31387     jresult = result;
31388   }
31389   return jresult;
31390 }
31391
31392
31393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31394   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31395   int arg2 ;
31396
31397   arg1 = (Dali::KeyEvent *)jarg1;
31398   arg2 = (int)jarg2;
31399   if (arg1) (arg1)->keyModifier = arg2;
31400 }
31401
31402
31403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31404   int jresult ;
31405   if( jarg1 == NULL )
31406   {
31407     jresult = -1;
31408   }
31409   else
31410   {
31411     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31412     int result;
31413
31414     arg1 = ( Dali::KeyEvent * )jarg1;
31415     result = (int)( ( arg1 )->keyModifier );
31416     jresult = result;
31417   }
31418   return jresult;
31419 }
31420
31421
31422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31423   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31424   unsigned long arg2 ;
31425
31426   arg1 = (Dali::KeyEvent *)jarg1;
31427   arg2 = (unsigned long)jarg2;
31428   if (arg1) (arg1)->time = arg2;
31429 }
31430
31431
31432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31433   unsigned long jresult ;
31434   if( jarg1 == NULL )
31435   {
31436     jresult = 0;
31437   }
31438   else
31439   {
31440     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31441     unsigned long result;
31442
31443     arg1 = ( Dali::KeyEvent * )jarg1;
31444     result = (unsigned long)( ( arg1 )->time );
31445     jresult = (unsigned long)result;
31446   }
31447   return jresult;
31448 }
31449
31450
31451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31452   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31453   Dali::KeyEvent::State arg2 ;
31454
31455   arg1 = (Dali::KeyEvent *)jarg1;
31456   arg2 = (Dali::KeyEvent::State)jarg2;
31457   if (arg1) (arg1)->state = arg2;
31458 }
31459
31460
31461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31462   int jresult ;
31463   if( jarg1 == NULL )
31464   {
31465     jresult = -1;
31466   }
31467   else
31468   {
31469     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31470     Dali::KeyEvent::State result;
31471
31472     arg1 = ( Dali::KeyEvent * )jarg1;
31473     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31474     jresult = (int)result;
31475   }
31476   return jresult;
31477 }
31478
31479
31480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31481   void * jresult ;
31482   Dali::LongPressGestureDetector *result = 0 ;
31483
31484   {
31485     try {
31486       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31487     } catch (std::out_of_range& e) {
31488       {
31489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31490       };
31491     } catch (std::exception& e) {
31492       {
31493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31494       };
31495     } catch (Dali::DaliException e) {
31496       {
31497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31498       };
31499     } catch (...) {
31500       {
31501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31502       };
31503     }
31504   }
31505
31506   jresult = (void *)result;
31507   return jresult;
31508 }
31509
31510
31511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31512   void * jresult ;
31513   Dali::LongPressGestureDetector result;
31514
31515   {
31516     try {
31517       result = Dali::LongPressGestureDetector::New();
31518     } catch (std::out_of_range& e) {
31519       {
31520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31521       };
31522     } catch (std::exception& e) {
31523       {
31524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31525       };
31526     } catch (Dali::DaliException e) {
31527       {
31528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31529       };
31530     } catch (...) {
31531       {
31532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31533       };
31534     }
31535   }
31536
31537   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31538   return jresult;
31539 }
31540
31541
31542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31543   void * jresult ;
31544   unsigned int arg1 ;
31545   Dali::LongPressGestureDetector result;
31546
31547   arg1 = (unsigned int)jarg1;
31548   {
31549     try {
31550       result = Dali::LongPressGestureDetector::New(arg1);
31551     } catch (std::out_of_range& e) {
31552       {
31553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31554       };
31555     } catch (std::exception& e) {
31556       {
31557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31558       };
31559     } catch (Dali::DaliException e) {
31560       {
31561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31562       };
31563     } catch (...) {
31564       {
31565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31566       };
31567     }
31568   }
31569
31570   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31571   return jresult;
31572 }
31573
31574
31575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31576   void * jresult ;
31577   unsigned int arg1 ;
31578   unsigned int arg2 ;
31579   Dali::LongPressGestureDetector result;
31580
31581   arg1 = (unsigned int)jarg1;
31582   arg2 = (unsigned int)jarg2;
31583   {
31584     try {
31585       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31586     } catch (std::out_of_range& e) {
31587       {
31588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31589       };
31590     } catch (std::exception& e) {
31591       {
31592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31593       };
31594     } catch (Dali::DaliException e) {
31595       {
31596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31597       };
31598     } catch (...) {
31599       {
31600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31601       };
31602     }
31603   }
31604
31605   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31606   return jresult;
31607 }
31608
31609
31610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31611   void * jresult ;
31612   Dali::BaseHandle arg1 ;
31613   Dali::BaseHandle *argp1 ;
31614   Dali::LongPressGestureDetector result;
31615
31616   argp1 = (Dali::BaseHandle *)jarg1;
31617   if (!argp1) {
31618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31619     return 0;
31620   }
31621   arg1 = *argp1;
31622   {
31623     try {
31624       result = Dali::LongPressGestureDetector::DownCast(arg1);
31625     } catch (std::out_of_range& e) {
31626       {
31627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31628       };
31629     } catch (std::exception& e) {
31630       {
31631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31632       };
31633     } catch (Dali::DaliException e) {
31634       {
31635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31636       };
31637     } catch (...) {
31638       {
31639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31640       };
31641     }
31642   }
31643
31644   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31645   return jresult;
31646 }
31647
31648
31649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31650   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31651
31652   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31653   {
31654     try {
31655       delete arg1;
31656     } catch (std::out_of_range& e) {
31657       {
31658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31659       };
31660     } catch (std::exception& e) {
31661       {
31662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31663       };
31664     } catch (Dali::DaliException e) {
31665       {
31666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31667       };
31668     } catch (...) {
31669       {
31670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31671       };
31672     }
31673   }
31674
31675 }
31676
31677
31678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31679   void * jresult ;
31680   Dali::LongPressGestureDetector *arg1 = 0 ;
31681   Dali::LongPressGestureDetector *result = 0 ;
31682
31683   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31684   if (!arg1) {
31685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31686     return 0;
31687   }
31688   {
31689     try {
31690       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31691     } catch (std::out_of_range& e) {
31692       {
31693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (std::exception& e) {
31696       {
31697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31698       };
31699     } catch (Dali::DaliException e) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31702       };
31703     } catch (...) {
31704       {
31705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31706       };
31707     }
31708   }
31709
31710   jresult = (void *)result;
31711   return jresult;
31712 }
31713
31714
31715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31716   void * jresult ;
31717   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31718   Dali::LongPressGestureDetector *arg2 = 0 ;
31719   Dali::LongPressGestureDetector *result = 0 ;
31720
31721   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31722   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31723   if (!arg2) {
31724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31725     return 0;
31726   }
31727   {
31728     try {
31729       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31730     } catch (std::out_of_range& e) {
31731       {
31732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31733       };
31734     } catch (std::exception& e) {
31735       {
31736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31737       };
31738     } catch (Dali::DaliException e) {
31739       {
31740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31741       };
31742     } catch (...) {
31743       {
31744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31745       };
31746     }
31747   }
31748
31749   jresult = (void *)result;
31750   return jresult;
31751 }
31752
31753
31754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31755   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31756   unsigned int arg2 ;
31757
31758   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31759   arg2 = (unsigned int)jarg2;
31760   {
31761     try {
31762       (arg1)->SetTouchesRequired(arg2);
31763     } catch (std::out_of_range& e) {
31764       {
31765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31766       };
31767     } catch (std::exception& e) {
31768       {
31769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31770       };
31771     } catch (Dali::DaliException e) {
31772       {
31773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31774       };
31775     } catch (...) {
31776       {
31777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31778       };
31779     }
31780   }
31781
31782 }
31783
31784
31785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31786   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31787   unsigned int arg2 ;
31788   unsigned int arg3 ;
31789
31790   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31791   arg2 = (unsigned int)jarg2;
31792   arg3 = (unsigned int)jarg3;
31793   {
31794     try {
31795       (arg1)->SetTouchesRequired(arg2,arg3);
31796     } catch (std::out_of_range& e) {
31797       {
31798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31799       };
31800     } catch (std::exception& e) {
31801       {
31802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31803       };
31804     } catch (Dali::DaliException e) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31807       };
31808     } catch (...) {
31809       {
31810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31811       };
31812     }
31813   }
31814
31815 }
31816
31817
31818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31819   unsigned int jresult ;
31820   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31821   unsigned int result;
31822
31823   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31824   {
31825     try {
31826       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31827     } catch (std::out_of_range& e) {
31828       {
31829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (std::exception& e) {
31832       {
31833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31834       };
31835     } catch (Dali::DaliException e) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31838       };
31839     } catch (...) {
31840       {
31841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31842       };
31843     }
31844   }
31845
31846   jresult = result;
31847   return jresult;
31848 }
31849
31850
31851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31852   unsigned int jresult ;
31853   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31854   unsigned int result;
31855
31856   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31857   {
31858     try {
31859       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31860     } catch (std::out_of_range& e) {
31861       {
31862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31863       };
31864     } catch (std::exception& e) {
31865       {
31866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31867       };
31868     } catch (Dali::DaliException e) {
31869       {
31870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31871       };
31872     } catch (...) {
31873       {
31874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31875       };
31876     }
31877   }
31878
31879   jresult = result;
31880   return jresult;
31881 }
31882
31883
31884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31885   void * jresult ;
31886   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31887   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31888
31889   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31890   {
31891     try {
31892       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31893     } catch (std::out_of_range& e) {
31894       {
31895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31896       };
31897     } catch (std::exception& e) {
31898       {
31899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31900       };
31901     } catch (Dali::DaliException e) {
31902       {
31903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31904       };
31905     } catch (...) {
31906       {
31907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31908       };
31909     }
31910   }
31911
31912   jresult = (void *)result;
31913   return jresult;
31914 }
31915
31916
31917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31918   void * jresult ;
31919   Dali::Gesture::State arg1 ;
31920   Dali::LongPressGesture *result = 0 ;
31921
31922   arg1 = (Dali::Gesture::State)jarg1;
31923   {
31924     try {
31925       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31926     } catch (std::out_of_range& e) {
31927       {
31928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31929       };
31930     } catch (std::exception& e) {
31931       {
31932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31933       };
31934     } catch (Dali::DaliException e) {
31935       {
31936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31937       };
31938     } catch (...) {
31939       {
31940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31941       };
31942     }
31943   }
31944
31945   jresult = (void *)result;
31946   return jresult;
31947 }
31948
31949
31950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31951   void * jresult ;
31952   Dali::LongPressGesture *arg1 = 0 ;
31953   Dali::LongPressGesture *result = 0 ;
31954
31955   arg1 = (Dali::LongPressGesture *)jarg1;
31956   if (!arg1) {
31957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31958     return 0;
31959   }
31960   {
31961     try {
31962       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31963     } catch (std::out_of_range& e) {
31964       {
31965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (std::exception& e) {
31968       {
31969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31970       };
31971     } catch (Dali::DaliException e) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31974       };
31975     } catch (...) {
31976       {
31977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31978       };
31979     }
31980   }
31981
31982   jresult = (void *)result;
31983   return jresult;
31984 }
31985
31986
31987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31988   void * jresult ;
31989   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31990   Dali::LongPressGesture *arg2 = 0 ;
31991   Dali::LongPressGesture *result = 0 ;
31992
31993   arg1 = (Dali::LongPressGesture *)jarg1;
31994   arg2 = (Dali::LongPressGesture *)jarg2;
31995   if (!arg2) {
31996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31997     return 0;
31998   }
31999   {
32000     try {
32001       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32002     } catch (std::out_of_range& e) {
32003       {
32004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32005       };
32006     } catch (std::exception& e) {
32007       {
32008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32009       };
32010     } catch (Dali::DaliException e) {
32011       {
32012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32013       };
32014     } catch (...) {
32015       {
32016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32017       };
32018     }
32019   }
32020
32021   jresult = (void *)result;
32022   return jresult;
32023 }
32024
32025
32026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32027   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32028
32029   arg1 = (Dali::LongPressGesture *)jarg1;
32030   {
32031     try {
32032       delete arg1;
32033     } catch (std::out_of_range& e) {
32034       {
32035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32036       };
32037     } catch (std::exception& e) {
32038       {
32039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32040       };
32041     } catch (Dali::DaliException e) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32044       };
32045     } catch (...) {
32046       {
32047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32048       };
32049     }
32050   }
32051
32052 }
32053
32054
32055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32056   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32057   unsigned int arg2 ;
32058
32059   arg1 = (Dali::LongPressGesture *)jarg1;
32060   arg2 = (unsigned int)jarg2;
32061   if (arg1) (arg1)->numberOfTouches = arg2;
32062 }
32063
32064
32065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32066   unsigned int jresult ;
32067   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32068   unsigned int result;
32069
32070   arg1 = (Dali::LongPressGesture *)jarg1;
32071   result = (unsigned int) ((arg1)->numberOfTouches);
32072   jresult = result;
32073   return jresult;
32074 }
32075
32076
32077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32078   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32079   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32080
32081   arg1 = (Dali::LongPressGesture *)jarg1;
32082   arg2 = (Dali::Vector2 *)jarg2;
32083   if (arg1) (arg1)->screenPoint = *arg2;
32084 }
32085
32086
32087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32088   void * jresult ;
32089   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32090   Dali::Vector2 *result = 0 ;
32091
32092   arg1 = (Dali::LongPressGesture *)jarg1;
32093   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32094   jresult = (void *)result;
32095   return jresult;
32096 }
32097
32098
32099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32100   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32101   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32102
32103   arg1 = (Dali::LongPressGesture *)jarg1;
32104   arg2 = (Dali::Vector2 *)jarg2;
32105   if (arg1) (arg1)->localPoint = *arg2;
32106 }
32107
32108
32109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32110   void * jresult ;
32111   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32112   Dali::Vector2 *result = 0 ;
32113
32114   arg1 = (Dali::LongPressGesture *)jarg1;
32115   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32116   jresult = (void *)result;
32117   return jresult;
32118 }
32119
32120
32121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32122   void * jresult ;
32123   Dali::WheelEvent *result = 0 ;
32124
32125   {
32126     try {
32127       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32128     } catch (std::out_of_range& e) {
32129       {
32130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32131       };
32132     } catch (std::exception& e) {
32133       {
32134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32135       };
32136     } catch (Dali::DaliException e) {
32137       {
32138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32139       };
32140     } catch (...) {
32141       {
32142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32143       };
32144     }
32145   }
32146
32147   jresult = (void *)result;
32148   return jresult;
32149 }
32150
32151
32152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32153   void * jresult ;
32154   Dali::WheelEvent::Type arg1 ;
32155   int arg2 ;
32156   unsigned int arg3 ;
32157   Dali::Vector2 arg4 ;
32158   int arg5 ;
32159   unsigned int arg6 ;
32160   Dali::Vector2 *argp4 ;
32161   Dali::WheelEvent *result = 0 ;
32162
32163   arg1 = (Dali::WheelEvent::Type)jarg1;
32164   arg2 = (int)jarg2;
32165   arg3 = (unsigned int)jarg3;
32166   argp4 = (Dali::Vector2 *)jarg4;
32167   if (!argp4) {
32168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32169     return 0;
32170   }
32171   arg4 = *argp4;
32172   arg5 = (int)jarg5;
32173   arg6 = (unsigned int)jarg6;
32174   {
32175     try {
32176       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32177     } catch (std::out_of_range& e) {
32178       {
32179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32180       };
32181     } catch (std::exception& e) {
32182       {
32183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32184       };
32185     } catch (Dali::DaliException e) {
32186       {
32187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32188       };
32189     } catch (...) {
32190       {
32191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32192       };
32193     }
32194   }
32195
32196   jresult = (void *)result;
32197   return jresult;
32198 }
32199
32200
32201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32202   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32203
32204   arg1 = (Dali::WheelEvent *)jarg1;
32205   {
32206     try {
32207       delete arg1;
32208     } catch (std::out_of_range& e) {
32209       {
32210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32211       };
32212     } catch (std::exception& e) {
32213       {
32214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32215       };
32216     } catch (Dali::DaliException e) {
32217       {
32218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32219       };
32220     } catch (...) {
32221       {
32222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32223       };
32224     }
32225   }
32226
32227 }
32228
32229
32230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32231   unsigned int jresult ;
32232   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32233   bool result;
32234
32235   arg1 = (Dali::WheelEvent *)jarg1;
32236   {
32237     try {
32238       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32239     } catch (std::out_of_range& e) {
32240       {
32241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32242       };
32243     } catch (std::exception& e) {
32244       {
32245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32246       };
32247     } catch (Dali::DaliException e) {
32248       {
32249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32250       };
32251     } catch (...) {
32252       {
32253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32254       };
32255     }
32256   }
32257
32258   jresult = result;
32259   return jresult;
32260 }
32261
32262
32263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32264   unsigned int jresult ;
32265   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32266   bool result;
32267
32268   arg1 = (Dali::WheelEvent *)jarg1;
32269   {
32270     try {
32271       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32272     } catch (std::out_of_range& e) {
32273       {
32274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32275       };
32276     } catch (std::exception& e) {
32277       {
32278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32279       };
32280     } catch (Dali::DaliException e) {
32281       {
32282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32283       };
32284     } catch (...) {
32285       {
32286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32287       };
32288     }
32289   }
32290
32291   jresult = result;
32292   return jresult;
32293 }
32294
32295
32296 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32297   unsigned int jresult ;
32298   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32299   bool result;
32300
32301   arg1 = (Dali::WheelEvent *)jarg1;
32302   {
32303     try {
32304       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32305     } catch (std::out_of_range& e) {
32306       {
32307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32308       };
32309     } catch (std::exception& e) {
32310       {
32311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32312       };
32313     } catch (Dali::DaliException e) {
32314       {
32315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32316       };
32317     } catch (...) {
32318       {
32319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32320       };
32321     }
32322   }
32323
32324   jresult = result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32330   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32331   Dali::WheelEvent::Type arg2 ;
32332
32333   arg1 = (Dali::WheelEvent *)jarg1;
32334   arg2 = (Dali::WheelEvent::Type)jarg2;
32335   if (arg1) (arg1)->type = arg2;
32336 }
32337
32338
32339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32340   int jresult ;
32341   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32342   Dali::WheelEvent::Type result;
32343
32344   arg1 = (Dali::WheelEvent *)jarg1;
32345   result = (Dali::WheelEvent::Type) ((arg1)->type);
32346   jresult = (int)result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32352   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32353   int arg2 ;
32354
32355   arg1 = (Dali::WheelEvent *)jarg1;
32356   arg2 = (int)jarg2;
32357   if (arg1) (arg1)->direction = arg2;
32358 }
32359
32360
32361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32362   int jresult ;
32363   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32364   int result;
32365
32366   arg1 = (Dali::WheelEvent *)jarg1;
32367   result = (int) ((arg1)->direction);
32368   jresult = result;
32369   return jresult;
32370 }
32371
32372
32373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32374   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32375   unsigned int arg2 ;
32376
32377   arg1 = (Dali::WheelEvent *)jarg1;
32378   arg2 = (unsigned int)jarg2;
32379   if (arg1) (arg1)->modifiers = arg2;
32380 }
32381
32382
32383 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32384   unsigned int jresult ;
32385   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32386   unsigned int result;
32387
32388   arg1 = (Dali::WheelEvent *)jarg1;
32389   result = (unsigned int) ((arg1)->modifiers);
32390   jresult = result;
32391   return jresult;
32392 }
32393
32394
32395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32396   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32397   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32398
32399   arg1 = (Dali::WheelEvent *)jarg1;
32400   arg2 = (Dali::Vector2 *)jarg2;
32401   if (arg1) (arg1)->point = *arg2;
32402 }
32403
32404
32405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32406   void * jresult ;
32407   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32408   Dali::Vector2 *result = 0 ;
32409
32410   arg1 = (Dali::WheelEvent *)jarg1;
32411   result = (Dali::Vector2 *)& ((arg1)->point);
32412   jresult = (void *)result;
32413   return jresult;
32414 }
32415
32416
32417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32418   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32419   int arg2 ;
32420
32421   arg1 = (Dali::WheelEvent *)jarg1;
32422   arg2 = (int)jarg2;
32423   if (arg1) (arg1)->z = arg2;
32424 }
32425
32426
32427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32428   int jresult ;
32429   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32430   int result;
32431
32432   arg1 = (Dali::WheelEvent *)jarg1;
32433   result = (int) ((arg1)->z);
32434   jresult = result;
32435   return jresult;
32436 }
32437
32438
32439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32440   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32441   unsigned int arg2 ;
32442
32443   arg1 = (Dali::WheelEvent *)jarg1;
32444   arg2 = (unsigned int)jarg2;
32445   if (arg1) (arg1)->timeStamp = arg2;
32446 }
32447
32448
32449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32450   unsigned int jresult ;
32451   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32452   unsigned int result;
32453
32454   arg1 = (Dali::WheelEvent *)jarg1;
32455   result = (unsigned int) ((arg1)->timeStamp);
32456   jresult = result;
32457   return jresult;
32458 }
32459
32460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32461   char * jresult ;
32462   Dali::KeyEvent *arg1 = 0 ;
32463   std::string result;
32464
32465   arg1 = (Dali::KeyEvent *)jarg1;
32466   if (!arg1) {
32467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32468     return 0;
32469   }
32470   {
32471     try {
32472       result = arg1->GetDeviceName();
32473     } catch (std::out_of_range& e) {
32474       {
32475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32476       };
32477     } catch (std::exception& e) {
32478       {
32479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32480       };
32481     } catch (Dali::DaliException e) {
32482       {
32483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32484       };
32485     } catch (...) {
32486       {
32487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32488       };
32489     }
32490   }
32491
32492   jresult = SWIG_csharp_string_callback((&result)->c_str());
32493   return jresult;
32494 }
32495
32496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32497   int jresult ;
32498   Dali::KeyEvent *arg1 = 0 ;
32499   Dali::Device::Class::Type result;
32500
32501   arg1 = (Dali::KeyEvent *)jarg1;
32502   if (!arg1) {
32503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32504     return 0;
32505   }
32506   {
32507     try {
32508       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32509     } catch (std::out_of_range& e) {
32510       {
32511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32512       };
32513     } catch (std::exception& e) {
32514       {
32515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32516       };
32517     } catch (Dali::DaliException e) {
32518       {
32519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32524       };
32525     }
32526   }
32527
32528   jresult = (int)result;
32529   return jresult;
32530 }
32531
32532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32533   int jresult ;
32534   Dali::KeyEvent *arg1 = 0 ;
32535   Dali::Device::Subclass::Type result;
32536
32537   arg1 = (Dali::KeyEvent *)jarg1;
32538   if (!arg1) {
32539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32540     return 0;
32541   }
32542   {
32543     try {
32544       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32545     } catch (std::out_of_range& e) {
32546       {
32547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32548       };
32549     } catch (std::exception& e) {
32550       {
32551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32552       };
32553     } catch (Dali::DaliException e) {
32554       {
32555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32556       };
32557     } catch (...) {
32558       {
32559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32560       };
32561     }
32562   }
32563
32564   jresult = (int)result;
32565   return jresult;
32566 }
32567
32568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32569   Dali::Actor arg1 ;
32570   Dali::Actor *argp1 ;
32571
32572   argp1 = (Dali::Actor *)jarg1;
32573   if (!argp1) {
32574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32575     return ;
32576   }
32577   arg1 = *argp1;
32578   {
32579     try {
32580       arg1.Raise();
32581     } catch (std::out_of_range& e) {
32582       {
32583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32584       };
32585     } catch (std::exception& e) {
32586       {
32587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32588       };
32589     } catch (Dali::DaliException e) {
32590       {
32591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32592       };
32593     } catch (...) {
32594       {
32595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32596       };
32597     }
32598   }
32599
32600 }
32601
32602
32603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32604   Dali::Actor arg1 ;
32605   Dali::Actor *argp1 ;
32606
32607   argp1 = (Dali::Actor *)jarg1;
32608   if (!argp1) {
32609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32610     return ;
32611   }
32612   arg1 = *argp1;
32613   {
32614     try {
32615       arg1.Lower();
32616     } catch (std::out_of_range& e) {
32617       {
32618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32619       };
32620     } catch (std::exception& e) {
32621       {
32622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32623       };
32624     } catch (Dali::DaliException e) {
32625       {
32626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32627       };
32628     } catch (...) {
32629       {
32630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32631       };
32632     }
32633   }
32634
32635 }
32636
32637
32638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32639   Dali::Actor arg1 ;
32640   Dali::Actor *argp1 ;
32641
32642   argp1 = (Dali::Actor *)jarg1;
32643   if (!argp1) {
32644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32645     return ;
32646   }
32647   arg1 = *argp1;
32648   {
32649     try {
32650       arg1.RaiseToTop();
32651     } catch (std::out_of_range& e) {
32652       {
32653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32654       };
32655     } catch (std::exception& e) {
32656       {
32657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32658       };
32659     } catch (Dali::DaliException e) {
32660       {
32661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32662       };
32663     } catch (...) {
32664       {
32665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32666       };
32667     }
32668   }
32669
32670 }
32671
32672
32673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32674   Dali::Actor arg1 ;
32675   Dali::Actor *argp1 ;
32676
32677   argp1 = (Dali::Actor *)jarg1;
32678   if (!argp1) {
32679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32680     return ;
32681   }
32682   arg1 = *argp1;
32683   {
32684     try {
32685       arg1.LowerToBottom();
32686     } catch (std::out_of_range& e) {
32687       {
32688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32689       };
32690     } catch (std::exception& e) {
32691       {
32692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32693       };
32694     } catch (Dali::DaliException e) {
32695       {
32696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32697       };
32698     } catch (...) {
32699       {
32700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32701       };
32702     }
32703   }
32704
32705 }
32706
32707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32708   Dali::Actor arg1 ;
32709   Dali::Actor arg2 ;
32710   Dali::Actor *argp1 ;
32711   Dali::Actor *argp2 ;
32712
32713   argp1 = (Dali::Actor *)jarg1;
32714   if (!argp1) {
32715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32716     return ;
32717   }
32718   arg1 = *argp1;
32719   argp2 = (Dali::Actor *)jarg2;
32720   if (!argp2) {
32721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32722     return ;
32723   }
32724   arg2 = *argp2;
32725   {
32726     try {
32727       arg1.RaiseAbove(arg2);
32728     } catch (std::out_of_range& e) {
32729       {
32730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32731       };
32732     } catch (std::exception& e) {
32733       {
32734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32735       };
32736     } catch (Dali::DaliException e) {
32737       {
32738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32739       };
32740     } catch (...) {
32741       {
32742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32743       };
32744     }
32745   }
32746
32747 }
32748
32749
32750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32751   Dali::Actor arg1 ;
32752   Dali::Actor arg2 ;
32753   Dali::Actor *argp1 ;
32754   Dali::Actor *argp2 ;
32755
32756   argp1 = (Dali::Actor *)jarg1;
32757   if (!argp1) {
32758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32759     return ;
32760   }
32761   arg1 = *argp1;
32762   argp2 = (Dali::Actor *)jarg2;
32763   if (!argp2) {
32764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32765     return ;
32766   }
32767   arg2 = *argp2;
32768   {
32769     try {
32770       arg1.LowerBelow(arg2);
32771     } catch (std::out_of_range& e) {
32772       {
32773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32774       };
32775     } catch (std::exception& e) {
32776       {
32777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32778       };
32779     } catch (Dali::DaliException e) {
32780       {
32781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32782       };
32783     } catch (...) {
32784       {
32785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32786       };
32787     }
32788   }
32789
32790 }
32791
32792
32793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32794   void * jresult ;
32795   Dali::Actor arg1 ;
32796   Dali::Actor *argp1 ;
32797   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32798
32799   argp1 = (Dali::Actor *)jarg1;
32800   if (!argp1) {
32801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32802     return 0;
32803   }
32804   arg1 = *argp1;
32805   {
32806     try {
32807       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32808     } catch (std::out_of_range& e) {
32809       {
32810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32811       };
32812     } catch (std::exception& e) {
32813       {
32814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32815       };
32816     } catch (Dali::DaliException e) {
32817       {
32818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32819       };
32820     } catch (...) {
32821       {
32822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32823       };
32824     }
32825   }
32826
32827   jresult = (void *)result;
32828   return jresult;
32829 }
32830
32831
32832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32833   void * jresult ;
32834   Dali::Actor *arg1 ;
32835   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32836
32837   arg1 = (Dali::Actor *)jarg1;
32838   {
32839     try {
32840       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32841     } catch (std::out_of_range& e) {
32842       {
32843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32844       };
32845     } catch (std::exception& e) {
32846       {
32847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32848       };
32849     } catch (Dali::DaliException e) {
32850       {
32851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32852       };
32853     } catch (...) {
32854       {
32855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32856       };
32857     }
32858   }
32859
32860   jresult = (void *)result;
32861   return jresult;
32862 }
32863
32864
32865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32866   int jresult ;
32867   int result;
32868
32869   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32870   jresult = (int)result;
32871   return jresult;
32872 }
32873
32874
32875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32876   int jresult ;
32877   int result;
32878
32879   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32880   jresult = (int)result;
32881   return jresult;
32882 }
32883
32884
32885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32886   int jresult ;
32887   int result;
32888
32889   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32890   jresult = (int)result;
32891   return jresult;
32892 }
32893
32894
32895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32896   int jresult ;
32897   int result;
32898
32899   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32900   jresult = (int)result;
32901   return jresult;
32902 }
32903
32904
32905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32906   int jresult ;
32907   int result;
32908
32909   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32910   jresult = (int)result;
32911   return jresult;
32912 }
32913
32914
32915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32916   int jresult ;
32917   int result;
32918
32919   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32920   jresult = (int)result;
32921   return jresult;
32922 }
32923
32924
32925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32926   int jresult ;
32927   int result;
32928
32929   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32930   jresult = (int)result;
32931   return jresult;
32932 }
32933
32934
32935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32936   int jresult ;
32937   int result;
32938
32939   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32940   jresult = (int)result;
32941   return jresult;
32942 }
32943
32944
32945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32946   int jresult ;
32947   int result;
32948
32949   result = (int)Dali::Actor::Property::SIZE;
32950   jresult = (int)result;
32951   return jresult;
32952 }
32953
32954
32955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32956   int jresult ;
32957   int result;
32958
32959   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32960   jresult = (int)result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32966   int jresult ;
32967   int result;
32968
32969   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32970   jresult = (int)result;
32971   return jresult;
32972 }
32973
32974
32975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32976   int jresult ;
32977   int result;
32978
32979   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32980   jresult = (int)result;
32981   return jresult;
32982 }
32983
32984
32985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32986   int jresult ;
32987   int result;
32988
32989   result = (int)Dali::Actor::Property::POSITION;
32990   jresult = (int)result;
32991   return jresult;
32992 }
32993
32994
32995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32996   int jresult ;
32997   int result;
32998
32999   result = (int)Dali::Actor::Property::POSITION_X;
33000   jresult = (int)result;
33001   return jresult;
33002 }
33003
33004
33005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33006   int jresult ;
33007   int result;
33008
33009   result = (int)Dali::Actor::Property::POSITION_Y;
33010   jresult = (int)result;
33011   return jresult;
33012 }
33013
33014
33015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33016   int jresult ;
33017   int result;
33018
33019   result = (int)Dali::Actor::Property::POSITION_Z;
33020   jresult = (int)result;
33021   return jresult;
33022 }
33023
33024
33025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33026   int jresult ;
33027   int result;
33028
33029   result = (int)Dali::Actor::Property::WORLD_POSITION;
33030   jresult = (int)result;
33031   return jresult;
33032 }
33033
33034
33035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33036   int jresult ;
33037   int result;
33038
33039   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33040   jresult = (int)result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33046   int jresult ;
33047   int result;
33048
33049   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33050   jresult = (int)result;
33051   return jresult;
33052 }
33053
33054
33055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33056   int jresult ;
33057   int result;
33058
33059   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33060   jresult = (int)result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33066   int jresult ;
33067   int result;
33068
33069   result = (int)Dali::Actor::Property::ORIENTATION;
33070   jresult = (int)result;
33071   return jresult;
33072 }
33073
33074
33075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33076   int jresult ;
33077   int result;
33078
33079   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33080   jresult = (int)result;
33081   return jresult;
33082 }
33083
33084
33085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33086   int jresult ;
33087   int result;
33088
33089   result = (int)Dali::Actor::Property::SCALE;
33090   jresult = (int)result;
33091   return jresult;
33092 }
33093
33094
33095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33096   int jresult ;
33097   int result;
33098
33099   result = (int)Dali::Actor::Property::SCALE_X;
33100   jresult = (int)result;
33101   return jresult;
33102 }
33103
33104
33105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33106   int jresult ;
33107   int result;
33108
33109   result = (int)Dali::Actor::Property::SCALE_Y;
33110   jresult = (int)result;
33111   return jresult;
33112 }
33113
33114
33115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33116   int jresult ;
33117   int result;
33118
33119   result = (int)Dali::Actor::Property::SCALE_Z;
33120   jresult = (int)result;
33121   return jresult;
33122 }
33123
33124
33125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33126   int jresult ;
33127   int result;
33128
33129   result = (int)Dali::Actor::Property::WORLD_SCALE;
33130   jresult = (int)result;
33131   return jresult;
33132 }
33133
33134
33135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33136   int jresult ;
33137   int result;
33138
33139   result = (int)Dali::Actor::Property::VISIBLE;
33140   jresult = (int)result;
33141   return jresult;
33142 }
33143
33144
33145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33146   int jresult ;
33147   int result;
33148
33149   result = (int)Dali::Actor::Property::COLOR;
33150   jresult = (int)result;
33151   return jresult;
33152 }
33153
33154
33155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33156   int jresult ;
33157   int result;
33158
33159   result = (int)Dali::Actor::Property::COLOR_RED;
33160   jresult = (int)result;
33161   return jresult;
33162 }
33163
33164
33165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33166   int jresult ;
33167   int result;
33168
33169   result = (int)Dali::Actor::Property::COLOR_GREEN;
33170   jresult = (int)result;
33171   return jresult;
33172 }
33173
33174
33175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33176   int jresult ;
33177   int result;
33178
33179   result = (int)Dali::Actor::Property::COLOR_BLUE;
33180   jresult = (int)result;
33181   return jresult;
33182 }
33183
33184
33185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33186   int jresult ;
33187   int result;
33188
33189   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33190   jresult = (int)result;
33191   return jresult;
33192 }
33193
33194
33195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33196   int jresult ;
33197   int result;
33198
33199   result = (int)Dali::Actor::Property::WORLD_COLOR;
33200   jresult = (int)result;
33201   return jresult;
33202 }
33203
33204
33205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33206   int jresult ;
33207   int result;
33208
33209   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33210   jresult = (int)result;
33211   return jresult;
33212 }
33213
33214
33215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33216   int jresult ;
33217   int result;
33218
33219   result = (int)Dali::Actor::Property::NAME;
33220   jresult = (int)result;
33221   return jresult;
33222 }
33223
33224
33225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33226   int jresult ;
33227   int result;
33228
33229   result = (int)Dali::Actor::Property::SENSITIVE;
33230   jresult = (int)result;
33231   return jresult;
33232 }
33233
33234
33235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33236   int jresult ;
33237   int result;
33238
33239   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33240   jresult = (int)result;
33241   return jresult;
33242 }
33243
33244
33245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33246   int jresult ;
33247   int result;
33248
33249   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33250   jresult = (int)result;
33251   return jresult;
33252 }
33253
33254
33255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33256   int jresult ;
33257   int result;
33258
33259   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33260   jresult = (int)result;
33261   return jresult;
33262 }
33263
33264
33265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33266   int jresult ;
33267   int result;
33268
33269   result = (int)Dali::Actor::Property::COLOR_MODE;
33270   jresult = (int)result;
33271   return jresult;
33272 }
33273
33274
33275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_INHERITANCE_get() {
33276   int jresult ;
33277   int result;
33278
33279   result = (int)Dali::Actor::Property::POSITION_INHERITANCE;
33280   jresult = (int)result;
33281   return jresult;
33282 }
33283
33284
33285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33286   int jresult ;
33287   int result;
33288
33289   result = (int)Dali::Actor::Property::DRAW_MODE;
33290   jresult = (int)result;
33291   return jresult;
33292 }
33293
33294
33295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33296   int jresult ;
33297   int result;
33298
33299   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33300   jresult = (int)result;
33301   return jresult;
33302 }
33303
33304
33305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33306   int jresult ;
33307   int result;
33308
33309   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33310   jresult = (int)result;
33311   return jresult;
33312 }
33313
33314
33315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33316   int jresult ;
33317   int result;
33318
33319   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33320   jresult = (int)result;
33321   return jresult;
33322 }
33323
33324
33325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33326   int jresult ;
33327   int result;
33328
33329   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33330   jresult = (int)result;
33331   return jresult;
33332 }
33333
33334
33335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33336   int jresult ;
33337   int result;
33338
33339   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33340   jresult = (int)result;
33341   return jresult;
33342 }
33343
33344
33345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33346   int jresult ;
33347   int result;
33348
33349   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33350   jresult = (int)result;
33351   return jresult;
33352 }
33353
33354
33355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33356   int jresult ;
33357   int result;
33358
33359   result = (int)Dali::Actor::Property::PADDING;
33360   jresult = (int)result;
33361   return jresult;
33362 }
33363
33364
33365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33366   int jresult ;
33367   int result;
33368
33369   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33370   jresult = (int)result;
33371   return jresult;
33372 }
33373
33374
33375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33376   int jresult ;
33377   int result;
33378
33379   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33380   jresult = (int)result;
33381   return jresult;
33382 }
33383
33384
33385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33386   int jresult ;
33387   int result;
33388
33389   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33390   jresult = (int)result;
33391   return jresult;
33392 }
33393
33394
33395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33396   int jresult ;
33397   int result;
33398
33399   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33400   jresult = (int)result;
33401   return jresult;
33402 }
33403
33404
33405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33406   void * jresult ;
33407   Dali::Actor::Property *result = 0 ;
33408
33409   {
33410     try {
33411       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33412     } catch (std::out_of_range& e) {
33413       {
33414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33415       };
33416     } catch (std::exception& e) {
33417       {
33418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (Dali::DaliException e) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33423       };
33424     } catch (...) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33427       };
33428     }
33429   }
33430
33431   jresult = (void *)result;
33432   return jresult;
33433 }
33434
33435
33436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33437   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33438
33439   arg1 = (Dali::Actor::Property *)jarg1;
33440   {
33441     try {
33442       delete arg1;
33443     } catch (std::out_of_range& e) {
33444       {
33445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33446       };
33447     } catch (std::exception& e) {
33448       {
33449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33450       };
33451     } catch (Dali::DaliException e) {
33452       {
33453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33454       };
33455     } catch (...) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33458       };
33459     }
33460   }
33461
33462 }
33463
33464
33465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33466   void * jresult ;
33467   Dali::Actor *result = 0 ;
33468
33469   {
33470     try {
33471       result = (Dali::Actor *)new Dali::Actor();
33472     } catch (std::out_of_range& e) {
33473       {
33474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (std::exception& e) {
33477       {
33478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (Dali::DaliException e) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33483       };
33484     } catch (...) {
33485       {
33486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33487       };
33488     }
33489   }
33490
33491   jresult = (void *)result;
33492   return jresult;
33493 }
33494
33495
33496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33497   void * jresult ;
33498   Dali::Actor result;
33499
33500   {
33501     try {
33502       result = Dali::Actor::New();
33503     } catch (std::out_of_range& e) {
33504       {
33505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33506       };
33507     } catch (std::exception& e) {
33508       {
33509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (Dali::DaliException e) {
33512       {
33513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33514       };
33515     } catch (...) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33518       };
33519     }
33520   }
33521
33522   jresult = new Dali::Actor((const Dali::Actor &)result);
33523   return jresult;
33524 }
33525
33526
33527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33528   void * jresult ;
33529   Dali::BaseHandle arg1 ;
33530   Dali::BaseHandle *argp1 ;
33531   Dali::Actor result;
33532
33533   argp1 = (Dali::BaseHandle *)jarg1;
33534   if (!argp1) {
33535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33536     return 0;
33537   }
33538   arg1 = *argp1;
33539   {
33540     try {
33541       result = Dali::Actor::DownCast(arg1);
33542     } catch (std::out_of_range& e) {
33543       {
33544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33545       };
33546     } catch (std::exception& e) {
33547       {
33548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33549       };
33550     } catch (Dali::DaliException e) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33557       };
33558     }
33559   }
33560
33561   jresult = new Dali::Actor((const Dali::Actor &)result);
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33567   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33568
33569   arg1 = (Dali::Actor *)jarg1;
33570   {
33571     try {
33572       delete arg1;
33573     } catch (std::out_of_range& e) {
33574       {
33575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33576       };
33577     } catch (std::exception& e) {
33578       {
33579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33580       };
33581     } catch (Dali::DaliException e) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33588       };
33589     }
33590   }
33591
33592 }
33593
33594
33595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33596   void * jresult ;
33597   Dali::Actor *arg1 = 0 ;
33598   Dali::Actor *result = 0 ;
33599
33600   arg1 = (Dali::Actor *)jarg1;
33601   if (!arg1) {
33602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33603     return 0;
33604   }
33605   {
33606     try {
33607       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33608     } catch (std::out_of_range& e) {
33609       {
33610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (std::exception& e) {
33613       {
33614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (Dali::DaliException e) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33619       };
33620     } catch (...) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33623       };
33624     }
33625   }
33626
33627   jresult = (void *)result;
33628   return jresult;
33629 }
33630
33631
33632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33633   void * jresult ;
33634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33635   Dali::Actor *arg2 = 0 ;
33636   Dali::Actor *result = 0 ;
33637
33638   arg1 = (Dali::Actor *)jarg1;
33639   arg2 = (Dali::Actor *)jarg2;
33640   if (!arg2) {
33641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33642     return 0;
33643   }
33644   {
33645     try {
33646       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33647     } catch (std::out_of_range& e) {
33648       {
33649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (std::exception& e) {
33652       {
33653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33654       };
33655     } catch (Dali::DaliException e) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33658       };
33659     } catch (...) {
33660       {
33661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33662       };
33663     }
33664   }
33665
33666   jresult = (void *)result;
33667   return jresult;
33668 }
33669
33670
33671 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33672   char * jresult ;
33673   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33674   std::string *result = 0 ;
33675
33676   arg1 = (Dali::Actor *)jarg1;
33677   {
33678     try {
33679       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33680     } catch (std::out_of_range& e) {
33681       {
33682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33683       };
33684     } catch (std::exception& e) {
33685       {
33686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33687       };
33688     } catch (Dali::DaliException e) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33691       };
33692     } catch (...) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33695       };
33696     }
33697   }
33698
33699   jresult = SWIG_csharp_string_callback(result->c_str());
33700   return jresult;
33701 }
33702
33703
33704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33706   std::string *arg2 = 0 ;
33707
33708   arg1 = (Dali::Actor *)jarg1;
33709   if (!jarg2) {
33710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33711     return ;
33712   }
33713   std::string arg2_str(jarg2);
33714   arg2 = &arg2_str;
33715   {
33716     try {
33717       (arg1)->SetName((std::string const &)*arg2);
33718     } catch (std::out_of_range& e) {
33719       {
33720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33721       };
33722     } catch (std::exception& e) {
33723       {
33724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (Dali::DaliException e) {
33727       {
33728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33729       };
33730     } catch (...) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33733       };
33734     }
33735   }
33736
33737
33738   //argout typemap for const std::string&
33739
33740 }
33741
33742
33743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33744   unsigned int jresult ;
33745   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33746   unsigned int result;
33747
33748   arg1 = (Dali::Actor *)jarg1;
33749   {
33750     try {
33751       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33752     } catch (std::out_of_range& e) {
33753       {
33754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33755       };
33756     } catch (std::exception& e) {
33757       {
33758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (Dali::DaliException e) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33763       };
33764     } catch (...) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33767       };
33768     }
33769   }
33770
33771   jresult = result;
33772   return jresult;
33773 }
33774
33775
33776 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33777   unsigned int jresult ;
33778   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33779   bool result;
33780
33781   arg1 = (Dali::Actor *)jarg1;
33782   {
33783     try {
33784       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33785     } catch (std::out_of_range& e) {
33786       {
33787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33788       };
33789     } catch (std::exception& e) {
33790       {
33791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (Dali::DaliException e) {
33794       {
33795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33796       };
33797     } catch (...) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33800       };
33801     }
33802   }
33803
33804   jresult = result;
33805   return jresult;
33806 }
33807
33808
33809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33810   unsigned int jresult ;
33811   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33812   bool result;
33813
33814   arg1 = (Dali::Actor *)jarg1;
33815   {
33816     try {
33817       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33818     } catch (std::out_of_range& e) {
33819       {
33820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (std::exception& e) {
33823       {
33824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (Dali::DaliException e) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33829       };
33830     } catch (...) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33833       };
33834     }
33835   }
33836
33837   jresult = result;
33838   return jresult;
33839 }
33840
33841
33842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33843   unsigned int jresult ;
33844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33845   bool result;
33846
33847   arg1 = (Dali::Actor *)jarg1;
33848   {
33849     try {
33850       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33851     } catch (std::out_of_range& e) {
33852       {
33853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33854       };
33855     } catch (std::exception& e) {
33856       {
33857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (Dali::DaliException e) {
33860       {
33861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33862       };
33863     } catch (...) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33866       };
33867     }
33868   }
33869
33870   jresult = result;
33871   return jresult;
33872 }
33873
33874
33875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33876   void * jresult ;
33877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33878   Dali::Layer result;
33879
33880   arg1 = (Dali::Actor *)jarg1;
33881   {
33882     try {
33883       result = (arg1)->GetLayer();
33884     } catch (std::out_of_range& e) {
33885       {
33886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33887       };
33888     } catch (std::exception& e) {
33889       {
33890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (Dali::DaliException e) {
33893       {
33894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33895       };
33896     } catch (...) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33899       };
33900     }
33901   }
33902
33903   jresult = new Dali::Layer((const Dali::Layer &)result);
33904   return jresult;
33905 }
33906
33907
33908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33909   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33910   Dali::Actor arg2 ;
33911   Dali::Actor *argp2 ;
33912
33913   arg1 = (Dali::Actor *)jarg1;
33914   argp2 = (Dali::Actor *)jarg2;
33915   if (!argp2) {
33916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33917     return ;
33918   }
33919   arg2 = *argp2;
33920   {
33921     try {
33922       (arg1)->Add(arg2);
33923     } catch (std::out_of_range& e) {
33924       {
33925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33926       };
33927     } catch (std::exception& e) {
33928       {
33929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33930       };
33931     } catch (Dali::DaliException e) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33934       };
33935     } catch (...) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33938       };
33939     }
33940   }
33941
33942 }
33943
33944
33945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33947   Dali::Actor arg2 ;
33948   Dali::Actor *argp2 ;
33949
33950   arg1 = (Dali::Actor *)jarg1;
33951   argp2 = (Dali::Actor *)jarg2;
33952   if (!argp2) {
33953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33954     return ;
33955   }
33956   arg2 = *argp2;
33957   {
33958     try {
33959       (arg1)->Remove(arg2);
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (Dali::DaliException e) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33971       };
33972     } catch (...) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33975       };
33976     }
33977   }
33978
33979 }
33980
33981
33982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33984
33985   arg1 = (Dali::Actor *)jarg1;
33986   {
33987     try {
33988       (arg1)->Unparent();
33989     } catch (std::out_of_range& e) {
33990       {
33991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33992       };
33993     } catch (std::exception& e) {
33994       {
33995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33996       };
33997     } catch (Dali::DaliException e) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34000       };
34001     } catch (...) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34004       };
34005     }
34006   }
34007
34008 }
34009
34010
34011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34012   unsigned int jresult ;
34013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34014   unsigned int result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   {
34018     try {
34019       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34020     } catch (std::out_of_range& e) {
34021       {
34022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (std::exception& e) {
34025       {
34026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (Dali::DaliException e) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34031       };
34032     } catch (...) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34035       };
34036     }
34037   }
34038
34039   jresult = result;
34040   return jresult;
34041 }
34042
34043
34044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34045   void * jresult ;
34046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34047   unsigned int arg2 ;
34048   Dali::Actor result;
34049
34050   arg1 = (Dali::Actor *)jarg1;
34051   arg2 = (unsigned int)jarg2;
34052   {
34053     try {
34054       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34055     } catch (std::out_of_range& e) {
34056       {
34057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34058       };
34059     } catch (std::exception& e) {
34060       {
34061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (Dali::DaliException e) {
34064       {
34065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34066       };
34067     } catch (...) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34070       };
34071     }
34072   }
34073
34074   jresult = new Dali::Actor((const Dali::Actor &)result);
34075   return jresult;
34076 }
34077
34078
34079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34080   void * jresult ;
34081   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34082   std::string *arg2 = 0 ;
34083   Dali::Actor result;
34084
34085   arg1 = (Dali::Actor *)jarg1;
34086   if (!jarg2) {
34087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34088     return 0;
34089   }
34090   std::string arg2_str(jarg2);
34091   arg2 = &arg2_str;
34092   {
34093     try {
34094       result = (arg1)->FindChildByName((std::string const &)*arg2);
34095     } catch (std::out_of_range& e) {
34096       {
34097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34098       };
34099     } catch (std::exception& e) {
34100       {
34101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (Dali::DaliException e) {
34104       {
34105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34106       };
34107     } catch (...) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34110       };
34111     }
34112   }
34113
34114   jresult = new Dali::Actor((const Dali::Actor &)result);
34115
34116   //argout typemap for const std::string&
34117
34118   return jresult;
34119 }
34120
34121
34122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34123   void * jresult ;
34124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34125   unsigned int arg2 ;
34126   Dali::Actor result;
34127
34128   arg1 = (Dali::Actor *)jarg1;
34129   arg2 = (unsigned int)jarg2;
34130   {
34131     try {
34132       result = (arg1)->FindChildById(arg2);
34133     } catch (std::out_of_range& e) {
34134       {
34135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34136       };
34137     } catch (std::exception& e) {
34138       {
34139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34140       };
34141     } catch (Dali::DaliException e) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34144       };
34145     } catch (...) {
34146       {
34147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34148       };
34149     }
34150   }
34151
34152   jresult = new Dali::Actor((const Dali::Actor &)result);
34153   return jresult;
34154 }
34155
34156
34157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34158   void * jresult ;
34159   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34160   Dali::Actor result;
34161
34162   arg1 = (Dali::Actor *)jarg1;
34163   {
34164     try {
34165       result = ((Dali::Actor const *)arg1)->GetParent();
34166     } catch (std::out_of_range& e) {
34167       {
34168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34169       };
34170     } catch (std::exception& e) {
34171       {
34172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34173       };
34174     } catch (Dali::DaliException e) {
34175       {
34176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34177       };
34178     } catch (...) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34181       };
34182     }
34183   }
34184
34185   jresult = new Dali::Actor((const Dali::Actor &)result);
34186   return jresult;
34187 }
34188
34189
34190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34191   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34192   Dali::Vector3 *arg2 = 0 ;
34193
34194   arg1 = (Dali::Actor *)jarg1;
34195   arg2 = (Dali::Vector3 *)jarg2;
34196   if (!arg2) {
34197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34198     return ;
34199   }
34200   {
34201     try {
34202       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34203     } catch (std::out_of_range& e) {
34204       {
34205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34206       };
34207     } catch (std::exception& e) {
34208       {
34209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34210       };
34211     } catch (Dali::DaliException e) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34214       };
34215     } catch (...) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34218       };
34219     }
34220   }
34221
34222 }
34223
34224
34225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34226   void * jresult ;
34227   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34228   Dali::Vector3 result;
34229
34230   arg1 = (Dali::Actor *)jarg1;
34231   {
34232     try {
34233       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34234     } catch (std::out_of_range& e) {
34235       {
34236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34237       };
34238     } catch (std::exception& e) {
34239       {
34240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34241       };
34242     } catch (Dali::DaliException e) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34245       };
34246     } catch (...) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34249       };
34250     }
34251   }
34252
34253   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34254   return jresult;
34255 }
34256
34257
34258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34259   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34260   Dali::Vector3 *arg2 = 0 ;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   arg2 = (Dali::Vector3 *)jarg2;
34264   if (!arg2) {
34265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34266     return ;
34267   }
34268   {
34269     try {
34270       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34271     } catch (std::out_of_range& e) {
34272       {
34273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34274       };
34275     } catch (std::exception& e) {
34276       {
34277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (Dali::DaliException e) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34282       };
34283     } catch (...) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34286       };
34287     }
34288   }
34289
34290 }
34291
34292
34293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34294   void * jresult ;
34295   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34296   Dali::Vector3 result;
34297
34298   arg1 = (Dali::Actor *)jarg1;
34299   {
34300     try {
34301       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34302     } catch (std::out_of_range& e) {
34303       {
34304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34305       };
34306     } catch (std::exception& e) {
34307       {
34308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34309       };
34310     } catch (Dali::DaliException e) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34317       };
34318     }
34319   }
34320
34321   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34322   return jresult;
34323 }
34324
34325
34326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34327   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34328   float arg2 ;
34329   float arg3 ;
34330
34331   arg1 = (Dali::Actor *)jarg1;
34332   arg2 = (float)jarg2;
34333   arg3 = (float)jarg3;
34334   {
34335     try {
34336       (arg1)->SetSize(arg2,arg3);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   float arg2 ;
34362   float arg3 ;
34363   float arg4 ;
34364
34365   arg1 = (Dali::Actor *)jarg1;
34366   arg2 = (float)jarg2;
34367   arg3 = (float)jarg3;
34368   arg4 = (float)jarg4;
34369   {
34370     try {
34371       (arg1)->SetSize(arg2,arg3,arg4);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (Dali::DaliException e) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34383       };
34384     } catch (...) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34387       };
34388     }
34389   }
34390
34391 }
34392
34393
34394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34396   Dali::Vector2 *arg2 = 0 ;
34397
34398   arg1 = (Dali::Actor *)jarg1;
34399   arg2 = (Dali::Vector2 *)jarg2;
34400   if (!arg2) {
34401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34402     return ;
34403   }
34404   {
34405     try {
34406       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34407     } catch (std::out_of_range& e) {
34408       {
34409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34410       };
34411     } catch (std::exception& e) {
34412       {
34413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34414       };
34415     } catch (Dali::DaliException e) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34418       };
34419     } catch (...) {
34420       {
34421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34422       };
34423     }
34424   }
34425
34426 }
34427
34428
34429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 *arg2 = 0 ;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   arg2 = (Dali::Vector3 *)jarg2;
34435   if (!arg2) {
34436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34437     return ;
34438   }
34439   {
34440     try {
34441       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34442     } catch (std::out_of_range& e) {
34443       {
34444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34445       };
34446     } catch (std::exception& e) {
34447       {
34448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34449       };
34450     } catch (Dali::DaliException e) {
34451       {
34452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34453       };
34454     } catch (...) {
34455       {
34456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34457       };
34458     }
34459   }
34460
34461 }
34462
34463
34464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34465   void * jresult ;
34466   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34467   Dali::Vector3 result;
34468
34469   arg1 = (Dali::Actor *)jarg1;
34470   {
34471     try {
34472       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34473     } catch (std::out_of_range& e) {
34474       {
34475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34476       };
34477     } catch (std::exception& e) {
34478       {
34479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34480       };
34481     } catch (Dali::DaliException e) {
34482       {
34483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34484       };
34485     } catch (...) {
34486       {
34487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34488       };
34489     }
34490   }
34491
34492   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34493   return jresult;
34494 }
34495
34496
34497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34498   void * jresult ;
34499   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34500   Dali::Vector3 result;
34501
34502   arg1 = (Dali::Actor *)jarg1;
34503   {
34504     try {
34505       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34506     } catch (std::out_of_range& e) {
34507       {
34508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34509       };
34510     } catch (std::exception& e) {
34511       {
34512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (Dali::DaliException e) {
34515       {
34516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34517       };
34518     } catch (...) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34521       };
34522     }
34523   }
34524
34525   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34526   return jresult;
34527 }
34528
34529
34530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34531   void * jresult ;
34532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34533   Dali::Vector3 result;
34534
34535   arg1 = (Dali::Actor *)jarg1;
34536   {
34537     try {
34538       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34539     } catch (std::out_of_range& e) {
34540       {
34541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34542       };
34543     } catch (std::exception& e) {
34544       {
34545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34546       };
34547     } catch (Dali::DaliException e) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34554       };
34555     }
34556   }
34557
34558   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34559   return jresult;
34560 }
34561
34562
34563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34564   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34565   float arg2 ;
34566   float arg3 ;
34567
34568   arg1 = (Dali::Actor *)jarg1;
34569   arg2 = (float)jarg2;
34570   arg3 = (float)jarg3;
34571   {
34572     try {
34573       (arg1)->SetPosition(arg2,arg3);
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (Dali::DaliException e) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34589       };
34590     }
34591   }
34592
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   float arg2 ;
34599   float arg3 ;
34600   float arg4 ;
34601
34602   arg1 = (Dali::Actor *)jarg1;
34603   arg2 = (float)jarg2;
34604   arg3 = (float)jarg3;
34605   arg4 = (float)jarg4;
34606   {
34607     try {
34608       (arg1)->SetPosition(arg2,arg3,arg4);
34609     } catch (std::out_of_range& e) {
34610       {
34611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (std::exception& e) {
34614       {
34615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34616       };
34617     } catch (Dali::DaliException e) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34620       };
34621     } catch (...) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34624       };
34625     }
34626   }
34627
34628 }
34629
34630
34631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34633   Dali::Vector3 *arg2 = 0 ;
34634
34635   arg1 = (Dali::Actor *)jarg1;
34636   arg2 = (Dali::Vector3 *)jarg2;
34637   if (!arg2) {
34638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34639     return ;
34640   }
34641   {
34642     try {
34643       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34644     } catch (std::out_of_range& e) {
34645       {
34646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34647       };
34648     } catch (std::exception& e) {
34649       {
34650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34651       };
34652     } catch (Dali::DaliException e) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34655       };
34656     } catch (...) {
34657       {
34658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34659       };
34660     }
34661   }
34662
34663 }
34664
34665
34666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34667   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34668   float arg2 ;
34669
34670   arg1 = (Dali::Actor *)jarg1;
34671   arg2 = (float)jarg2;
34672   {
34673     try {
34674       (arg1)->SetX(arg2);
34675     } catch (std::out_of_range& e) {
34676       {
34677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (std::exception& e) {
34680       {
34681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34682       };
34683     } catch (Dali::DaliException e) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34686       };
34687     } catch (...) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34690       };
34691     }
34692   }
34693
34694 }
34695
34696
34697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34698   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34699   float arg2 ;
34700
34701   arg1 = (Dali::Actor *)jarg1;
34702   arg2 = (float)jarg2;
34703   {
34704     try {
34705       (arg1)->SetY(arg2);
34706     } catch (std::out_of_range& e) {
34707       {
34708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (std::exception& e) {
34711       {
34712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (Dali::DaliException e) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34717       };
34718     } catch (...) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34721       };
34722     }
34723   }
34724
34725 }
34726
34727
34728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34729   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34730   float arg2 ;
34731
34732   arg1 = (Dali::Actor *)jarg1;
34733   arg2 = (float)jarg2;
34734   {
34735     try {
34736       (arg1)->SetZ(arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   Dali::Vector3 *arg2 = 0 ;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   arg2 = (Dali::Vector3 *)jarg2;
34765   if (!arg2) {
34766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34767     return ;
34768   }
34769   {
34770     try {
34771       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34772     } catch (std::out_of_range& e) {
34773       {
34774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34775       };
34776     } catch (std::exception& e) {
34777       {
34778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34779       };
34780     } catch (Dali::DaliException e) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34783       };
34784     } catch (...) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34787       };
34788     }
34789   }
34790
34791 }
34792
34793
34794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34795   void * jresult ;
34796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34797   Dali::Vector3 result;
34798
34799   arg1 = (Dali::Actor *)jarg1;
34800   {
34801     try {
34802       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34803     } catch (std::out_of_range& e) {
34804       {
34805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34806       };
34807     } catch (std::exception& e) {
34808       {
34809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (Dali::DaliException e) {
34812       {
34813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34814       };
34815     } catch (...) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34818       };
34819     }
34820   }
34821
34822   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34823   return jresult;
34824 }
34825
34826
34827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34828   void * jresult ;
34829   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34830   Dali::Vector3 result;
34831
34832   arg1 = (Dali::Actor *)jarg1;
34833   {
34834     try {
34835       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34836     } catch (std::out_of_range& e) {
34837       {
34838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34839       };
34840     } catch (std::exception& e) {
34841       {
34842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34843       };
34844     } catch (Dali::DaliException e) {
34845       {
34846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34847       };
34848     } catch (...) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34851       };
34852     }
34853   }
34854
34855   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34856   return jresult;
34857 }
34858
34859
34860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34862   bool arg2 ;
34863
34864   arg1 = (Dali::Actor *)jarg1;
34865   arg2 = jarg2 ? true : false;
34866   {
34867     try {
34868       (arg1)->SetInheritPosition(arg2);
34869     } catch (std::out_of_range& e) {
34870       {
34871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34872       };
34873     } catch (std::exception& e) {
34874       {
34875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34876       };
34877     } catch (Dali::DaliException e) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34880       };
34881     } catch (...) {
34882       {
34883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34884       };
34885     }
34886   }
34887
34888 }
34889
34890
34891 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetPositionInheritanceMode(void * jarg1) {
34892   int jresult ;
34893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34894   Dali::PositionInheritanceMode result;
34895
34896   arg1 = (Dali::Actor *)jarg1;
34897   {
34898     try {
34899       result = (Dali::PositionInheritanceMode)((Dali::Actor const *)arg1)->GetPositionInheritanceMode();
34900     } catch (std::out_of_range& e) {
34901       {
34902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34903       };
34904     } catch (std::exception& e) {
34905       {
34906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (Dali::DaliException e) {
34909       {
34910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34911       };
34912     } catch (...) {
34913       {
34914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34915       };
34916     }
34917   }
34918
34919   jresult = (int)result;
34920   return jresult;
34921 }
34922
34923
34924 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34925   unsigned int jresult ;
34926   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34927   bool result;
34928
34929   arg1 = (Dali::Actor *)jarg1;
34930   {
34931     try {
34932       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34933     } catch (std::out_of_range& e) {
34934       {
34935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34936       };
34937     } catch (std::exception& e) {
34938       {
34939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34940       };
34941     } catch (Dali::DaliException e) {
34942       {
34943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34944       };
34945     } catch (...) {
34946       {
34947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34948       };
34949     }
34950   }
34951
34952   jresult = result;
34953   return jresult;
34954 }
34955
34956
34957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34958   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34959   Dali::Degree *arg2 = 0 ;
34960   Dali::Vector3 *arg3 = 0 ;
34961
34962   arg1 = (Dali::Actor *)jarg1;
34963   arg2 = (Dali::Degree *)jarg2;
34964   if (!arg2) {
34965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34966     return ;
34967   }
34968   arg3 = (Dali::Vector3 *)jarg3;
34969   if (!arg3) {
34970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34971     return ;
34972   }
34973   {
34974     try {
34975       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34976     } catch (std::out_of_range& e) {
34977       {
34978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34979       };
34980     } catch (std::exception& e) {
34981       {
34982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34983       };
34984     } catch (Dali::DaliException e) {
34985       {
34986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34987       };
34988     } catch (...) {
34989       {
34990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34991       };
34992     }
34993   }
34994
34995 }
34996
34997
34998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34999   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35000   Dali::Radian *arg2 = 0 ;
35001   Dali::Vector3 *arg3 = 0 ;
35002
35003   arg1 = (Dali::Actor *)jarg1;
35004   arg2 = (Dali::Radian *)jarg2;
35005   if (!arg2) {
35006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35007     return ;
35008   }
35009   arg3 = (Dali::Vector3 *)jarg3;
35010   if (!arg3) {
35011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35012     return ;
35013   }
35014   {
35015     try {
35016       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35017     } catch (std::out_of_range& e) {
35018       {
35019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35020       };
35021     } catch (std::exception& e) {
35022       {
35023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35024       };
35025     } catch (Dali::DaliException e) {
35026       {
35027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35028       };
35029     } catch (...) {
35030       {
35031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35032       };
35033     }
35034   }
35035
35036 }
35037
35038
35039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35040   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35041   Dali::Quaternion *arg2 = 0 ;
35042
35043   arg1 = (Dali::Actor *)jarg1;
35044   arg2 = (Dali::Quaternion *)jarg2;
35045   if (!arg2) {
35046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35047     return ;
35048   }
35049   {
35050     try {
35051       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35052     } catch (std::out_of_range& e) {
35053       {
35054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35055       };
35056     } catch (std::exception& e) {
35057       {
35058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35059       };
35060     } catch (Dali::DaliException e) {
35061       {
35062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35063       };
35064     } catch (...) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35067       };
35068     }
35069   }
35070
35071 }
35072
35073
35074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35075   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35076   Dali::Degree *arg2 = 0 ;
35077   Dali::Vector3 *arg3 = 0 ;
35078
35079   arg1 = (Dali::Actor *)jarg1;
35080   arg2 = (Dali::Degree *)jarg2;
35081   if (!arg2) {
35082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35083     return ;
35084   }
35085   arg3 = (Dali::Vector3 *)jarg3;
35086   if (!arg3) {
35087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35088     return ;
35089   }
35090   {
35091     try {
35092       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35093     } catch (std::out_of_range& e) {
35094       {
35095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35096       };
35097     } catch (std::exception& e) {
35098       {
35099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35100       };
35101     } catch (Dali::DaliException e) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35104       };
35105     } catch (...) {
35106       {
35107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35108       };
35109     }
35110   }
35111
35112 }
35113
35114
35115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35117   Dali::Radian *arg2 = 0 ;
35118   Dali::Vector3 *arg3 = 0 ;
35119
35120   arg1 = (Dali::Actor *)jarg1;
35121   arg2 = (Dali::Radian *)jarg2;
35122   if (!arg2) {
35123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35124     return ;
35125   }
35126   arg3 = (Dali::Vector3 *)jarg3;
35127   if (!arg3) {
35128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35129     return ;
35130   }
35131   {
35132     try {
35133       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35134     } catch (std::out_of_range& e) {
35135       {
35136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35137       };
35138     } catch (std::exception& e) {
35139       {
35140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35141       };
35142     } catch (Dali::DaliException e) {
35143       {
35144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35145       };
35146     } catch (...) {
35147       {
35148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35149       };
35150     }
35151   }
35152
35153 }
35154
35155
35156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35158   Dali::Quaternion *arg2 = 0 ;
35159
35160   arg1 = (Dali::Actor *)jarg1;
35161   arg2 = (Dali::Quaternion *)jarg2;
35162   if (!arg2) {
35163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35164     return ;
35165   }
35166   {
35167     try {
35168       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35169     } catch (std::out_of_range& e) {
35170       {
35171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35172       };
35173     } catch (std::exception& e) {
35174       {
35175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35176       };
35177     } catch (Dali::DaliException e) {
35178       {
35179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35180       };
35181     } catch (...) {
35182       {
35183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35184       };
35185     }
35186   }
35187
35188 }
35189
35190
35191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35192   void * jresult ;
35193   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35194   Dali::Quaternion result;
35195
35196   arg1 = (Dali::Actor *)jarg1;
35197   {
35198     try {
35199       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35200     } catch (std::out_of_range& e) {
35201       {
35202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35203       };
35204     } catch (std::exception& e) {
35205       {
35206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35207       };
35208     } catch (Dali::DaliException e) {
35209       {
35210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35211       };
35212     } catch (...) {
35213       {
35214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35215       };
35216     }
35217   }
35218
35219   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35220   return jresult;
35221 }
35222
35223
35224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35226   bool arg2 ;
35227
35228   arg1 = (Dali::Actor *)jarg1;
35229   arg2 = jarg2 ? true : false;
35230   {
35231     try {
35232       (arg1)->SetInheritOrientation(arg2);
35233     } catch (std::out_of_range& e) {
35234       {
35235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35236       };
35237     } catch (std::exception& e) {
35238       {
35239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35240       };
35241     } catch (Dali::DaliException e) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35244       };
35245     } catch (...) {
35246       {
35247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35248       };
35249     }
35250   }
35251
35252 }
35253
35254
35255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35256   unsigned int jresult ;
35257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35258   bool result;
35259
35260   arg1 = (Dali::Actor *)jarg1;
35261   {
35262     try {
35263       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35264     } catch (std::out_of_range& e) {
35265       {
35266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35267       };
35268     } catch (std::exception& e) {
35269       {
35270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35271       };
35272     } catch (Dali::DaliException e) {
35273       {
35274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35275       };
35276     } catch (...) {
35277       {
35278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35279       };
35280     }
35281   }
35282
35283   jresult = result;
35284   return jresult;
35285 }
35286
35287
35288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35289   void * jresult ;
35290   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35291   Dali::Quaternion result;
35292
35293   arg1 = (Dali::Actor *)jarg1;
35294   {
35295     try {
35296       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35297     } catch (std::out_of_range& e) {
35298       {
35299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35300       };
35301     } catch (std::exception& e) {
35302       {
35303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35304       };
35305     } catch (Dali::DaliException e) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35312       };
35313     }
35314   }
35315
35316   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35317   return jresult;
35318 }
35319
35320
35321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35322   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35323   float arg2 ;
35324
35325   arg1 = (Dali::Actor *)jarg1;
35326   arg2 = (float)jarg2;
35327   {
35328     try {
35329       (arg1)->SetScale(arg2);
35330     } catch (std::out_of_range& e) {
35331       {
35332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35333       };
35334     } catch (std::exception& e) {
35335       {
35336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35337       };
35338     } catch (Dali::DaliException e) {
35339       {
35340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35341       };
35342     } catch (...) {
35343       {
35344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35345       };
35346     }
35347   }
35348
35349 }
35350
35351
35352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35353   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35354   float arg2 ;
35355   float arg3 ;
35356   float arg4 ;
35357
35358   arg1 = (Dali::Actor *)jarg1;
35359   arg2 = (float)jarg2;
35360   arg3 = (float)jarg3;
35361   arg4 = (float)jarg4;
35362   {
35363     try {
35364       (arg1)->SetScale(arg2,arg3,arg4);
35365     } catch (std::out_of_range& e) {
35366       {
35367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35368       };
35369     } catch (std::exception& e) {
35370       {
35371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35372       };
35373     } catch (Dali::DaliException e) {
35374       {
35375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35376       };
35377     } catch (...) {
35378       {
35379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35380       };
35381     }
35382   }
35383
35384 }
35385
35386
35387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35388   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35389   Dali::Vector3 *arg2 = 0 ;
35390
35391   arg1 = (Dali::Actor *)jarg1;
35392   arg2 = (Dali::Vector3 *)jarg2;
35393   if (!arg2) {
35394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35395     return ;
35396   }
35397   {
35398     try {
35399       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35400     } catch (std::out_of_range& e) {
35401       {
35402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35403       };
35404     } catch (std::exception& e) {
35405       {
35406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35407       };
35408     } catch (Dali::DaliException e) {
35409       {
35410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35411       };
35412     } catch (...) {
35413       {
35414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35415       };
35416     }
35417   }
35418
35419 }
35420
35421
35422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35424   Dali::Vector3 *arg2 = 0 ;
35425
35426   arg1 = (Dali::Actor *)jarg1;
35427   arg2 = (Dali::Vector3 *)jarg2;
35428   if (!arg2) {
35429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35430     return ;
35431   }
35432   {
35433     try {
35434       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35435     } catch (std::out_of_range& e) {
35436       {
35437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35438       };
35439     } catch (std::exception& e) {
35440       {
35441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35442       };
35443     } catch (Dali::DaliException e) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35446       };
35447     } catch (...) {
35448       {
35449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35450       };
35451     }
35452   }
35453
35454 }
35455
35456
35457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35458   void * jresult ;
35459   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35460   Dali::Vector3 result;
35461
35462   arg1 = (Dali::Actor *)jarg1;
35463   {
35464     try {
35465       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35466     } catch (std::out_of_range& e) {
35467       {
35468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35469       };
35470     } catch (std::exception& e) {
35471       {
35472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (Dali::DaliException e) {
35475       {
35476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35477       };
35478     } catch (...) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35481       };
35482     }
35483   }
35484
35485   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35486   return jresult;
35487 }
35488
35489
35490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35491   void * jresult ;
35492   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35493   Dali::Vector3 result;
35494
35495   arg1 = (Dali::Actor *)jarg1;
35496   {
35497     try {
35498       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35499     } catch (std::out_of_range& e) {
35500       {
35501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (std::exception& e) {
35504       {
35505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35506       };
35507     } catch (Dali::DaliException e) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35510       };
35511     } catch (...) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35514       };
35515     }
35516   }
35517
35518   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35519   return jresult;
35520 }
35521
35522
35523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35524   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35525   bool arg2 ;
35526
35527   arg1 = (Dali::Actor *)jarg1;
35528   arg2 = jarg2 ? true : false;
35529   {
35530     try {
35531       (arg1)->SetInheritScale(arg2);
35532     } catch (std::out_of_range& e) {
35533       {
35534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35535       };
35536     } catch (std::exception& e) {
35537       {
35538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35539       };
35540     } catch (Dali::DaliException e) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35543       };
35544     } catch (...) {
35545       {
35546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35547       };
35548     }
35549   }
35550
35551 }
35552
35553
35554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35555   unsigned int jresult ;
35556   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35557   bool result;
35558
35559   arg1 = (Dali::Actor *)jarg1;
35560   {
35561     try {
35562       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35563     } catch (std::out_of_range& e) {
35564       {
35565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35566       };
35567     } catch (std::exception& e) {
35568       {
35569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35570       };
35571     } catch (Dali::DaliException e) {
35572       {
35573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35574       };
35575     } catch (...) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35578       };
35579     }
35580   }
35581
35582   jresult = result;
35583   return jresult;
35584 }
35585
35586
35587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35588   void * jresult ;
35589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35590   Dali::Matrix result;
35591
35592   arg1 = (Dali::Actor *)jarg1;
35593   {
35594     try {
35595       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35596     } catch (std::out_of_range& e) {
35597       {
35598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (std::exception& e) {
35601       {
35602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35603       };
35604     } catch (Dali::DaliException e) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35607       };
35608     } catch (...) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35611       };
35612     }
35613   }
35614
35615   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35616   return jresult;
35617 }
35618
35619
35620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35622   bool arg2 ;
35623
35624   arg1 = (Dali::Actor *)jarg1;
35625   arg2 = jarg2 ? true : false;
35626   {
35627     try {
35628       (arg1)->SetVisible(arg2);
35629     } catch (std::out_of_range& e) {
35630       {
35631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (std::exception& e) {
35634       {
35635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35636       };
35637     } catch (Dali::DaliException e) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35640       };
35641     } catch (...) {
35642       {
35643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35644       };
35645     }
35646   }
35647
35648 }
35649
35650
35651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35652   unsigned int jresult ;
35653   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35654   bool result;
35655
35656   arg1 = (Dali::Actor *)jarg1;
35657   {
35658     try {
35659       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35660     } catch (std::out_of_range& e) {
35661       {
35662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (std::exception& e) {
35665       {
35666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35667       };
35668     } catch (Dali::DaliException e) {
35669       {
35670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35671       };
35672     } catch (...) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35675       };
35676     }
35677   }
35678
35679   jresult = result;
35680   return jresult;
35681 }
35682
35683
35684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35685   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35686   float arg2 ;
35687
35688   arg1 = (Dali::Actor *)jarg1;
35689   arg2 = (float)jarg2;
35690   {
35691     try {
35692       (arg1)->SetOpacity(arg2);
35693     } catch (std::out_of_range& e) {
35694       {
35695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35696       };
35697     } catch (std::exception& e) {
35698       {
35699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (Dali::DaliException e) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711
35712 }
35713
35714
35715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35716   float jresult ;
35717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35718   float result;
35719
35720   arg1 = (Dali::Actor *)jarg1;
35721   {
35722     try {
35723       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35724     } catch (std::out_of_range& e) {
35725       {
35726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35727       };
35728     } catch (std::exception& e) {
35729       {
35730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35731       };
35732     } catch (Dali::DaliException e) {
35733       {
35734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35735       };
35736     } catch (...) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35739       };
35740     }
35741   }
35742
35743   jresult = result;
35744   return jresult;
35745 }
35746
35747
35748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35750   Dali::Vector4 *arg2 = 0 ;
35751
35752   arg1 = (Dali::Actor *)jarg1;
35753   arg2 = (Dali::Vector4 *)jarg2;
35754   if (!arg2) {
35755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35756     return ;
35757   }
35758   {
35759     try {
35760       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35761     } catch (std::out_of_range& e) {
35762       {
35763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (std::exception& e) {
35766       {
35767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35768       };
35769     } catch (Dali::DaliException e) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35772       };
35773     } catch (...) {
35774       {
35775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35776       };
35777     }
35778   }
35779
35780 }
35781
35782
35783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35784   void * jresult ;
35785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35786   Dali::Vector4 result;
35787
35788   arg1 = (Dali::Actor *)jarg1;
35789   {
35790     try {
35791       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35792     } catch (std::out_of_range& e) {
35793       {
35794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35795       };
35796     } catch (std::exception& e) {
35797       {
35798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35799       };
35800     } catch (Dali::DaliException e) {
35801       {
35802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35803       };
35804     } catch (...) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35807       };
35808     }
35809   }
35810
35811   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35812   return jresult;
35813 }
35814
35815
35816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35818   Dali::ColorMode arg2 ;
35819
35820   arg1 = (Dali::Actor *)jarg1;
35821   arg2 = (Dali::ColorMode)jarg2;
35822   {
35823     try {
35824       (arg1)->SetColorMode(arg2);
35825     } catch (std::out_of_range& e) {
35826       {
35827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35828       };
35829     } catch (std::exception& e) {
35830       {
35831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35832       };
35833     } catch (Dali::DaliException e) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35836       };
35837     } catch (...) {
35838       {
35839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35840       };
35841     }
35842   }
35843
35844 }
35845
35846
35847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35848   int jresult ;
35849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35850   Dali::ColorMode result;
35851
35852   arg1 = (Dali::Actor *)jarg1;
35853   {
35854     try {
35855       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35856     } catch (std::out_of_range& e) {
35857       {
35858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35859       };
35860     } catch (std::exception& e) {
35861       {
35862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35863       };
35864     } catch (Dali::DaliException e) {
35865       {
35866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35867       };
35868     } catch (...) {
35869       {
35870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35871       };
35872     }
35873   }
35874
35875   jresult = (int)result;
35876   return jresult;
35877 }
35878
35879
35880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35881   void * jresult ;
35882   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35883   Dali::Vector4 result;
35884
35885   arg1 = (Dali::Actor *)jarg1;
35886   {
35887     try {
35888       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35889     } catch (std::out_of_range& e) {
35890       {
35891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (std::exception& e) {
35894       {
35895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35896       };
35897     } catch (Dali::DaliException e) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35900       };
35901     } catch (...) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35904       };
35905     }
35906   }
35907
35908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35909   return jresult;
35910 }
35911
35912
35913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35915   Dali::DrawMode::Type arg2 ;
35916
35917   arg1 = (Dali::Actor *)jarg1;
35918   arg2 = (Dali::DrawMode::Type)jarg2;
35919   {
35920     try {
35921       (arg1)->SetDrawMode(arg2);
35922     } catch (std::out_of_range& e) {
35923       {
35924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35925       };
35926     } catch (std::exception& e) {
35927       {
35928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35929       };
35930     } catch (Dali::DaliException e) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35933       };
35934     } catch (...) {
35935       {
35936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35937       };
35938     }
35939   }
35940
35941 }
35942
35943
35944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35945   int jresult ;
35946   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35947   Dali::DrawMode::Type result;
35948
35949   arg1 = (Dali::Actor *)jarg1;
35950   {
35951     try {
35952       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35953     } catch (std::out_of_range& e) {
35954       {
35955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (std::exception& e) {
35958       {
35959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35960       };
35961     } catch (Dali::DaliException e) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35964       };
35965     } catch (...) {
35966       {
35967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35968       };
35969     }
35970   }
35971
35972   jresult = (int)result;
35973   return jresult;
35974 }
35975
35976
35977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35979   bool arg2 ;
35980
35981   arg1 = (Dali::Actor *)jarg1;
35982   arg2 = jarg2 ? true : false;
35983   {
35984     try {
35985       (arg1)->SetSensitive(arg2);
35986     } catch (std::out_of_range& e) {
35987       {
35988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35989       };
35990     } catch (std::exception& e) {
35991       {
35992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35993       };
35994     } catch (Dali::DaliException e) {
35995       {
35996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35997       };
35998     } catch (...) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36001       };
36002     }
36003   }
36004
36005 }
36006
36007
36008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36009   unsigned int jresult ;
36010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36011   bool result;
36012
36013   arg1 = (Dali::Actor *)jarg1;
36014   {
36015     try {
36016       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
36017     } catch (std::out_of_range& e) {
36018       {
36019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36020       };
36021     } catch (std::exception& e) {
36022       {
36023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36024       };
36025     } catch (Dali::DaliException e) {
36026       {
36027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36028       };
36029     } catch (...) {
36030       {
36031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36032       };
36033     }
36034   }
36035
36036   jresult = result;
36037   return jresult;
36038 }
36039
36040
36041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36042   unsigned int jresult ;
36043   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36044   float *arg2 = 0 ;
36045   float *arg3 = 0 ;
36046   float arg4 ;
36047   float arg5 ;
36048   bool result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   arg2 = (float *)jarg2;
36052   arg3 = (float *)jarg3;
36053   arg4 = (float)jarg4;
36054   arg5 = (float)jarg5;
36055   {
36056     try {
36057       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36058     } catch (std::out_of_range& e) {
36059       {
36060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (std::exception& e) {
36063       {
36064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36065       };
36066     } catch (Dali::DaliException e) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36069       };
36070     } catch (...) {
36071       {
36072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36073       };
36074     }
36075   }
36076
36077   jresult = result;
36078   return jresult;
36079 }
36080
36081
36082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36083   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36084   bool arg2 ;
36085
36086   arg1 = (Dali::Actor *)jarg1;
36087   arg2 = jarg2 ? true : false;
36088   {
36089     try {
36090       (arg1)->SetLeaveRequired(arg2);
36091     } catch (std::out_of_range& e) {
36092       {
36093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36094       };
36095     } catch (std::exception& e) {
36096       {
36097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36098       };
36099     } catch (Dali::DaliException e) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36102       };
36103     } catch (...) {
36104       {
36105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36106       };
36107     }
36108   }
36109
36110 }
36111
36112
36113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36114   unsigned int jresult ;
36115   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36116   bool result;
36117
36118   arg1 = (Dali::Actor *)jarg1;
36119   {
36120     try {
36121       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36122     } catch (std::out_of_range& e) {
36123       {
36124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (std::exception& e) {
36127       {
36128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36129       };
36130     } catch (Dali::DaliException e) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36133       };
36134     } catch (...) {
36135       {
36136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36137       };
36138     }
36139   }
36140
36141   jresult = result;
36142   return jresult;
36143 }
36144
36145
36146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36148   bool arg2 ;
36149
36150   arg1 = (Dali::Actor *)jarg1;
36151   arg2 = jarg2 ? true : false;
36152   {
36153     try {
36154       (arg1)->SetKeyboardFocusable(arg2);
36155     } catch (std::out_of_range& e) {
36156       {
36157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36158       };
36159     } catch (std::exception& e) {
36160       {
36161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36162       };
36163     } catch (Dali::DaliException e) {
36164       {
36165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36166       };
36167     } catch (...) {
36168       {
36169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36170       };
36171     }
36172   }
36173
36174 }
36175
36176
36177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36178   unsigned int jresult ;
36179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36180   bool result;
36181
36182   arg1 = (Dali::Actor *)jarg1;
36183   {
36184     try {
36185       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36186     } catch (std::out_of_range& e) {
36187       {
36188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36189       };
36190     } catch (std::exception& e) {
36191       {
36192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36193       };
36194     } catch (Dali::DaliException e) {
36195       {
36196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36197       };
36198     } catch (...) {
36199       {
36200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36201       };
36202     }
36203   }
36204
36205   jresult = result;
36206   return jresult;
36207 }
36208
36209
36210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36212   Dali::ResizePolicy::Type arg2 ;
36213   Dali::Dimension::Type arg3 ;
36214
36215   arg1 = (Dali::Actor *)jarg1;
36216   arg2 = (Dali::ResizePolicy::Type)jarg2;
36217   arg3 = (Dali::Dimension::Type)jarg3;
36218   {
36219     try {
36220       (arg1)->SetResizePolicy(arg2,arg3);
36221     } catch (std::out_of_range& e) {
36222       {
36223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36224       };
36225     } catch (std::exception& e) {
36226       {
36227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36228       };
36229     } catch (Dali::DaliException e) {
36230       {
36231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36232       };
36233     } catch (...) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36236       };
36237     }
36238   }
36239
36240 }
36241
36242
36243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36244   int jresult ;
36245   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36246   Dali::Dimension::Type arg2 ;
36247   Dali::ResizePolicy::Type result;
36248
36249   arg1 = (Dali::Actor *)jarg1;
36250   arg2 = (Dali::Dimension::Type)jarg2;
36251   {
36252     try {
36253       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36254     } catch (std::out_of_range& e) {
36255       {
36256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (std::exception& e) {
36259       {
36260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36261       };
36262     } catch (Dali::DaliException e) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36265       };
36266     } catch (...) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36269       };
36270     }
36271   }
36272
36273   jresult = (int)result;
36274   return jresult;
36275 }
36276
36277
36278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36280   Dali::SizeScalePolicy::Type arg2 ;
36281
36282   arg1 = (Dali::Actor *)jarg1;
36283   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36284   {
36285     try {
36286       (arg1)->SetSizeScalePolicy(arg2);
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36310   int jresult ;
36311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36312   Dali::SizeScalePolicy::Type result;
36313
36314   arg1 = (Dali::Actor *)jarg1;
36315   {
36316     try {
36317       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36318     } catch (std::out_of_range& e) {
36319       {
36320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (std::exception& e) {
36323       {
36324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36325       };
36326     } catch (Dali::DaliException e) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36329       };
36330     } catch (...) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36333       };
36334     }
36335   }
36336
36337   jresult = (int)result;
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36343   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36344   Dali::Vector3 *arg2 = 0 ;
36345
36346   arg1 = (Dali::Actor *)jarg1;
36347   arg2 = (Dali::Vector3 *)jarg2;
36348   if (!arg2) {
36349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36350     return ;
36351   }
36352   {
36353     try {
36354       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36362       };
36363     } catch (Dali::DaliException e) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36366       };
36367     } catch (...) {
36368       {
36369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36370       };
36371     }
36372   }
36373
36374 }
36375
36376
36377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36378   void * jresult ;
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   Dali::Vector3 result;
36381
36382   arg1 = (Dali::Actor *)jarg1;
36383   {
36384     try {
36385       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36386     } catch (std::out_of_range& e) {
36387       {
36388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36389       };
36390     } catch (std::exception& e) {
36391       {
36392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36393       };
36394     } catch (Dali::DaliException e) {
36395       {
36396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36397       };
36398     } catch (...) {
36399       {
36400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36401       };
36402     }
36403   }
36404
36405   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36406   return jresult;
36407 }
36408
36409
36410 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36411   float jresult ;
36412   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36413   float arg2 ;
36414   float result;
36415
36416   arg1 = (Dali::Actor *)jarg1;
36417   arg2 = (float)jarg2;
36418   {
36419     try {
36420       result = (float)(arg1)->GetHeightForWidth(arg2);
36421     } catch (std::out_of_range& e) {
36422       {
36423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36424       };
36425     } catch (std::exception& e) {
36426       {
36427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (Dali::DaliException e) {
36430       {
36431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439
36440   jresult = result;
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36446   float jresult ;
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   float arg2 ;
36449   float result;
36450
36451   arg1 = (Dali::Actor *)jarg1;
36452   arg2 = (float)jarg2;
36453   {
36454     try {
36455       result = (float)(arg1)->GetWidthForHeight(arg2);
36456     } catch (std::out_of_range& e) {
36457       {
36458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36459       };
36460     } catch (std::exception& e) {
36461       {
36462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36463       };
36464     } catch (Dali::DaliException e) {
36465       {
36466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36467       };
36468     } catch (...) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36471       };
36472     }
36473   }
36474
36475   jresult = result;
36476   return jresult;
36477 }
36478
36479
36480 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36481   float jresult ;
36482   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36483   Dali::Dimension::Type arg2 ;
36484   float result;
36485
36486   arg1 = (Dali::Actor *)jarg1;
36487   arg2 = (Dali::Dimension::Type)jarg2;
36488   {
36489     try {
36490       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36491     } catch (std::out_of_range& e) {
36492       {
36493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36494       };
36495     } catch (std::exception& e) {
36496       {
36497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36498       };
36499     } catch (Dali::DaliException e) {
36500       {
36501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36502       };
36503     } catch (...) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36506       };
36507     }
36508   }
36509
36510   jresult = result;
36511   return jresult;
36512 }
36513
36514
36515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36516   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36517   Dali::Padding *arg2 = 0 ;
36518
36519   arg1 = (Dali::Actor *)jarg1;
36520   arg2 = (Dali::Padding *)jarg2;
36521   if (!arg2) {
36522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36523     return ;
36524   }
36525   {
36526     try {
36527       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36528     } catch (std::out_of_range& e) {
36529       {
36530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36531       };
36532     } catch (std::exception& e) {
36533       {
36534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36535       };
36536     } catch (Dali::DaliException e) {
36537       {
36538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36539       };
36540     } catch (...) {
36541       {
36542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36543       };
36544     }
36545   }
36546
36547 }
36548
36549
36550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36552   Dali::Padding *arg2 = 0 ;
36553
36554   arg1 = (Dali::Actor *)jarg1;
36555   arg2 = (Dali::Padding *)jarg2;
36556   if (!arg2) {
36557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36558     return ;
36559   }
36560   {
36561     try {
36562       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36563     } catch (std::out_of_range& e) {
36564       {
36565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36566       };
36567     } catch (std::exception& e) {
36568       {
36569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36570       };
36571     } catch (Dali::DaliException e) {
36572       {
36573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36574       };
36575     } catch (...) {
36576       {
36577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36578       };
36579     }
36580   }
36581
36582 }
36583
36584
36585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36587   Dali::Vector2 *arg2 = 0 ;
36588
36589   arg1 = (Dali::Actor *)jarg1;
36590   arg2 = (Dali::Vector2 *)jarg2;
36591   if (!arg2) {
36592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36593     return ;
36594   }
36595   {
36596     try {
36597       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36598     } catch (std::out_of_range& e) {
36599       {
36600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36601       };
36602     } catch (std::exception& e) {
36603       {
36604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (Dali::DaliException e) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36609       };
36610     } catch (...) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36613       };
36614     }
36615   }
36616
36617 }
36618
36619
36620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36621   void * jresult ;
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   Dali::Vector2 result;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   {
36627     try {
36628       result = (arg1)->GetMinimumSize();
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36644       };
36645     }
36646   }
36647
36648   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   Dali::Vector2 *arg2 = 0 ;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   arg2 = (Dali::Vector2 *)jarg2;
36659   if (!arg2) {
36660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36661     return ;
36662   }
36663   {
36664     try {
36665       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36666     } catch (std::out_of_range& e) {
36667       {
36668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36669       };
36670     } catch (std::exception& e) {
36671       {
36672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36673       };
36674     } catch (Dali::DaliException e) {
36675       {
36676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36677       };
36678     } catch (...) {
36679       {
36680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36681       };
36682     }
36683   }
36684
36685 }
36686
36687
36688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36689   void * jresult ;
36690   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36691   Dali::Vector2 result;
36692
36693   arg1 = (Dali::Actor *)jarg1;
36694   {
36695     try {
36696       result = (arg1)->GetMaximumSize();
36697     } catch (std::out_of_range& e) {
36698       {
36699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36700       };
36701     } catch (std::exception& e) {
36702       {
36703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (Dali::DaliException e) {
36706       {
36707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36708       };
36709     } catch (...) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36712       };
36713     }
36714   }
36715
36716   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36717   return jresult;
36718 }
36719
36720
36721 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36722   int jresult ;
36723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36724   int result;
36725
36726   arg1 = (Dali::Actor *)jarg1;
36727   {
36728     try {
36729       result = (int)(arg1)->GetHierarchyDepth();
36730     } catch (std::out_of_range& e) {
36731       {
36732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36733       };
36734     } catch (std::exception& e) {
36735       {
36736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36737       };
36738     } catch (Dali::DaliException e) {
36739       {
36740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36741       };
36742     } catch (...) {
36743       {
36744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36745       };
36746     }
36747   }
36748
36749   jresult = result;
36750   return jresult;
36751 }
36752
36753
36754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36755   unsigned int jresult ;
36756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36757   Dali::Renderer *arg2 = 0 ;
36758   unsigned int result;
36759
36760   arg1 = (Dali::Actor *)jarg1;
36761   arg2 = (Dali::Renderer *)jarg2;
36762   if (!arg2) {
36763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36764     return 0;
36765   }
36766   {
36767     try {
36768       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36769     } catch (std::out_of_range& e) {
36770       {
36771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36772       };
36773     } catch (std::exception& e) {
36774       {
36775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36776       };
36777     } catch (Dali::DaliException e) {
36778       {
36779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36780       };
36781     } catch (...) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36784       };
36785     }
36786   }
36787
36788   jresult = result;
36789   return jresult;
36790 }
36791
36792
36793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36794   unsigned int jresult ;
36795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36796   unsigned int result;
36797
36798   arg1 = (Dali::Actor *)jarg1;
36799   {
36800     try {
36801       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36802     } catch (std::out_of_range& e) {
36803       {
36804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36805       };
36806     } catch (std::exception& e) {
36807       {
36808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36809       };
36810     } catch (Dali::DaliException e) {
36811       {
36812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36813       };
36814     } catch (...) {
36815       {
36816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36817       };
36818     }
36819   }
36820
36821   jresult = result;
36822   return jresult;
36823 }
36824
36825
36826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36827   void * jresult ;
36828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36829   unsigned int arg2 ;
36830   Dali::Renderer result;
36831
36832   arg1 = (Dali::Actor *)jarg1;
36833   arg2 = (unsigned int)jarg2;
36834   {
36835     try {
36836       result = (arg1)->GetRendererAt(arg2);
36837     } catch (std::out_of_range& e) {
36838       {
36839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36840       };
36841     } catch (std::exception& e) {
36842       {
36843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36844       };
36845     } catch (Dali::DaliException e) {
36846       {
36847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36848       };
36849     } catch (...) {
36850       {
36851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36852       };
36853     }
36854   }
36855
36856   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36857   return jresult;
36858 }
36859
36860
36861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36863   Dali::Renderer *arg2 = 0 ;
36864
36865   arg1 = (Dali::Actor *)jarg1;
36866   arg2 = (Dali::Renderer *)jarg2;
36867   if (!arg2) {
36868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36869     return ;
36870   }
36871   {
36872     try {
36873       (arg1)->RemoveRenderer(*arg2);
36874     } catch (std::out_of_range& e) {
36875       {
36876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36877       };
36878     } catch (std::exception& e) {
36879       {
36880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36881       };
36882     } catch (Dali::DaliException e) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36885       };
36886     } catch (...) {
36887       {
36888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36889       };
36890     }
36891   }
36892
36893 }
36894
36895
36896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36898   unsigned int arg2 ;
36899
36900   arg1 = (Dali::Actor *)jarg1;
36901   arg2 = (unsigned int)jarg2;
36902   {
36903     try {
36904       (arg1)->RemoveRenderer(arg2);
36905     } catch (std::out_of_range& e) {
36906       {
36907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36908       };
36909     } catch (std::exception& e) {
36910       {
36911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36912       };
36913     } catch (Dali::DaliException e) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36916       };
36917     } catch (...) {
36918       {
36919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36920       };
36921     }
36922   }
36923
36924 }
36925
36926
36927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36928   void * jresult ;
36929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36930   Dali::Actor::TouchSignalType *result = 0 ;
36931
36932   arg1 = (Dali::Actor *)jarg1;
36933   {
36934     try {
36935       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36936     } catch (std::out_of_range& e) {
36937       {
36938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36939       };
36940     } catch (std::exception& e) {
36941       {
36942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36943       };
36944     } catch (Dali::DaliException e) {
36945       {
36946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36947       };
36948     } catch (...) {
36949       {
36950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36951       };
36952     }
36953   }
36954
36955   jresult = (void *)result;
36956   return jresult;
36957 }
36958
36959
36960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36961   void * jresult ;
36962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36963   Dali::Actor::TouchDataSignalType *result = 0 ;
36964
36965   arg1 = (Dali::Actor *)jarg1;
36966   {
36967     try {
36968       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36969     } catch (std::out_of_range& e) {
36970       {
36971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36972       };
36973     } catch (std::exception& e) {
36974       {
36975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36976       };
36977     } catch (Dali::DaliException e) {
36978       {
36979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36980       };
36981     } catch (...) {
36982       {
36983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36984       };
36985     }
36986   }
36987
36988   jresult = (void *)result;
36989   return jresult;
36990 }
36991
36992
36993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36994   void * jresult ;
36995   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36996   Dali::Actor::HoverSignalType *result = 0 ;
36997
36998   arg1 = (Dali::Actor *)jarg1;
36999   {
37000     try {
37001       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37002     } catch (std::out_of_range& e) {
37003       {
37004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37005       };
37006     } catch (std::exception& e) {
37007       {
37008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37009       };
37010     } catch (Dali::DaliException e) {
37011       {
37012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37013       };
37014     } catch (...) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37017       };
37018     }
37019   }
37020
37021   jresult = (void *)result;
37022   return jresult;
37023 }
37024
37025
37026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37027   void * jresult ;
37028   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37029   Dali::Actor::WheelEventSignalType *result = 0 ;
37030
37031   arg1 = (Dali::Actor *)jarg1;
37032   {
37033     try {
37034       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37042       };
37043     } catch (Dali::DaliException e) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37046       };
37047     } catch (...) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37050       };
37051     }
37052   }
37053
37054   jresult = (void *)result;
37055   return jresult;
37056 }
37057
37058
37059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37060   void * jresult ;
37061   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37062   Dali::Actor::OnStageSignalType *result = 0 ;
37063
37064   arg1 = (Dali::Actor *)jarg1;
37065   {
37066     try {
37067       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37068     } catch (std::out_of_range& e) {
37069       {
37070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37071       };
37072     } catch (std::exception& e) {
37073       {
37074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37075       };
37076     } catch (Dali::DaliException e) {
37077       {
37078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37079       };
37080     } catch (...) {
37081       {
37082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37083       };
37084     }
37085   }
37086
37087   jresult = (void *)result;
37088   return jresult;
37089 }
37090
37091
37092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37093   void * jresult ;
37094   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37095   Dali::Actor::OffStageSignalType *result = 0 ;
37096
37097   arg1 = (Dali::Actor *)jarg1;
37098   {
37099     try {
37100       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37101     } catch (std::out_of_range& e) {
37102       {
37103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37104       };
37105     } catch (std::exception& e) {
37106       {
37107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37108       };
37109     } catch (Dali::DaliException e) {
37110       {
37111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37112       };
37113     } catch (...) {
37114       {
37115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37116       };
37117     }
37118   }
37119
37120   jresult = (void *)result;
37121   return jresult;
37122 }
37123
37124
37125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37126   void * jresult ;
37127   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37128   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37129
37130   arg1 = (Dali::Actor *)jarg1;
37131   {
37132     try {
37133       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37134     } catch (std::out_of_range& e) {
37135       {
37136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37137       };
37138     } catch (std::exception& e) {
37139       {
37140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37141       };
37142     } catch (Dali::DaliException e) {
37143       {
37144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37145       };
37146     } catch (...) {
37147       {
37148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37149       };
37150     }
37151   }
37152
37153   jresult = (void *)result;
37154   return jresult;
37155 }
37156
37157
37158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37159   Dali::Actor *arg1 = 0 ;
37160
37161   arg1 = (Dali::Actor *)jarg1;
37162   if (!arg1) {
37163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37164     return ;
37165   }
37166   {
37167     try {
37168       Dali::UnparentAndReset(*arg1);
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37176       };
37177     } catch (Dali::DaliException e) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37180       };
37181     } catch (...) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37184       };
37185     }
37186   }
37187
37188 }
37189
37190
37191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37192   int jresult ;
37193   int result;
37194
37195   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37196   jresult = (int)result;
37197   return jresult;
37198 }
37199
37200
37201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37202   int jresult ;
37203   int result;
37204
37205   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37206   jresult = (int)result;
37207   return jresult;
37208 }
37209
37210
37211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37212   int jresult ;
37213   int result;
37214
37215   result = (int)Dali::Layer::Property::BEHAVIOR;
37216   jresult = (int)result;
37217   return jresult;
37218 }
37219
37220
37221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37222   void * jresult ;
37223   Dali::Layer::Property *result = 0 ;
37224
37225   {
37226     try {
37227       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37228     } catch (std::out_of_range& e) {
37229       {
37230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (std::exception& e) {
37233       {
37234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37235       };
37236     } catch (Dali::DaliException e) {
37237       {
37238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37239       };
37240     } catch (...) {
37241       {
37242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37243       };
37244     }
37245   }
37246
37247   jresult = (void *)result;
37248   return jresult;
37249 }
37250
37251
37252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37253   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37254
37255   arg1 = (Dali::Layer::Property *)jarg1;
37256   {
37257     try {
37258       delete arg1;
37259     } catch (std::out_of_range& e) {
37260       {
37261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37262       };
37263     } catch (std::exception& e) {
37264       {
37265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37266       };
37267     } catch (Dali::DaliException e) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37270       };
37271     } catch (...) {
37272       {
37273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37274       };
37275     }
37276   }
37277
37278 }
37279
37280
37281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37282   void * jresult ;
37283   Dali::Layer *result = 0 ;
37284
37285   {
37286     try {
37287       result = (Dali::Layer *)new Dali::Layer();
37288     } catch (std::out_of_range& e) {
37289       {
37290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37291       };
37292     } catch (std::exception& e) {
37293       {
37294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37295       };
37296     } catch (Dali::DaliException e) {
37297       {
37298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37299       };
37300     } catch (...) {
37301       {
37302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37303       };
37304     }
37305   }
37306
37307   jresult = (void *)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37313   void * jresult ;
37314   Dali::Layer result;
37315
37316   {
37317     try {
37318       result = Dali::Layer::New();
37319     } catch (std::out_of_range& e) {
37320       {
37321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37322       };
37323     } catch (std::exception& e) {
37324       {
37325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37326       };
37327     } catch (Dali::DaliException e) {
37328       {
37329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37330       };
37331     } catch (...) {
37332       {
37333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37334       };
37335     }
37336   }
37337
37338   jresult = new Dali::Layer((const Dali::Layer &)result);
37339   return jresult;
37340 }
37341
37342
37343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37344   void * jresult ;
37345   Dali::BaseHandle arg1 ;
37346   Dali::BaseHandle *argp1 ;
37347   Dali::Layer result;
37348
37349   argp1 = (Dali::BaseHandle *)jarg1;
37350   if (!argp1) {
37351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37352     return 0;
37353   }
37354   arg1 = *argp1;
37355   {
37356     try {
37357       result = Dali::Layer::DownCast(arg1);
37358     } catch (std::out_of_range& e) {
37359       {
37360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37361       };
37362     } catch (std::exception& e) {
37363       {
37364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37365       };
37366     } catch (Dali::DaliException e) {
37367       {
37368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37369       };
37370     } catch (...) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37373       };
37374     }
37375   }
37376
37377   jresult = new Dali::Layer((const Dali::Layer &)result);
37378   return jresult;
37379 }
37380
37381
37382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37383   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37384
37385   arg1 = (Dali::Layer *)jarg1;
37386   {
37387     try {
37388       delete arg1;
37389     } catch (std::out_of_range& e) {
37390       {
37391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37392       };
37393     } catch (std::exception& e) {
37394       {
37395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37396       };
37397     } catch (Dali::DaliException e) {
37398       {
37399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37400       };
37401     } catch (...) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37404       };
37405     }
37406   }
37407
37408 }
37409
37410
37411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37412   void * jresult ;
37413   Dali::Layer *arg1 = 0 ;
37414   Dali::Layer *result = 0 ;
37415
37416   arg1 = (Dali::Layer *)jarg1;
37417   if (!arg1) {
37418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37419     return 0;
37420   }
37421   {
37422     try {
37423       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37424     } catch (std::out_of_range& e) {
37425       {
37426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37427       };
37428     } catch (std::exception& e) {
37429       {
37430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37431       };
37432     } catch (Dali::DaliException e) {
37433       {
37434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37435       };
37436     } catch (...) {
37437       {
37438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37439       };
37440     }
37441   }
37442
37443   jresult = (void *)result;
37444   return jresult;
37445 }
37446
37447
37448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37449   void * jresult ;
37450   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37451   Dali::Layer *arg2 = 0 ;
37452   Dali::Layer *result = 0 ;
37453
37454   arg1 = (Dali::Layer *)jarg1;
37455   arg2 = (Dali::Layer *)jarg2;
37456   if (!arg2) {
37457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37458     return 0;
37459   }
37460   {
37461     try {
37462       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37463     } catch (std::out_of_range& e) {
37464       {
37465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37466       };
37467     } catch (std::exception& e) {
37468       {
37469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37470       };
37471     } catch (Dali::DaliException e) {
37472       {
37473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37474       };
37475     } catch (...) {
37476       {
37477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37478       };
37479     }
37480   }
37481
37482   jresult = (void *)result;
37483   return jresult;
37484 }
37485
37486
37487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37488   unsigned int jresult ;
37489   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37490   unsigned int result;
37491
37492   arg1 = (Dali::Layer *)jarg1;
37493   {
37494     try {
37495       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37503       };
37504     } catch (Dali::DaliException e) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37507       };
37508     } catch (...) {
37509       {
37510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37511       };
37512     }
37513   }
37514
37515   jresult = result;
37516   return jresult;
37517 }
37518
37519
37520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37521   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37522
37523   arg1 = (Dali::Layer *)jarg1;
37524   {
37525     try {
37526       (arg1)->Raise();
37527     } catch (std::out_of_range& e) {
37528       {
37529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37530       };
37531     } catch (std::exception& e) {
37532       {
37533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37534       };
37535     } catch (Dali::DaliException e) {
37536       {
37537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37538       };
37539     } catch (...) {
37540       {
37541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37542       };
37543     }
37544   }
37545
37546 }
37547
37548
37549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37550   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37551
37552   arg1 = (Dali::Layer *)jarg1;
37553   {
37554     try {
37555       (arg1)->Lower();
37556     } catch (std::out_of_range& e) {
37557       {
37558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37559       };
37560     } catch (std::exception& e) {
37561       {
37562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37563       };
37564     } catch (Dali::DaliException e) {
37565       {
37566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37567       };
37568     } catch (...) {
37569       {
37570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37571       };
37572     }
37573   }
37574
37575 }
37576
37577
37578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37579   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37580   Dali::Layer arg2 ;
37581   Dali::Layer *argp2 ;
37582
37583   arg1 = (Dali::Layer *)jarg1;
37584   argp2 = (Dali::Layer *)jarg2;
37585   if (!argp2) {
37586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37587     return ;
37588   }
37589   arg2 = *argp2;
37590   {
37591     try {
37592       (arg1)->RaiseAbove(arg2);
37593     } catch (std::out_of_range& e) {
37594       {
37595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37596       };
37597     } catch (std::exception& e) {
37598       {
37599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37600       };
37601     } catch (Dali::DaliException e) {
37602       {
37603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37604       };
37605     } catch (...) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37608       };
37609     }
37610   }
37611
37612 }
37613
37614
37615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37616   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37617   Dali::Layer arg2 ;
37618   Dali::Layer *argp2 ;
37619
37620   arg1 = (Dali::Layer *)jarg1;
37621   argp2 = (Dali::Layer *)jarg2;
37622   if (!argp2) {
37623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37624     return ;
37625   }
37626   arg2 = *argp2;
37627   {
37628     try {
37629       (arg1)->LowerBelow(arg2);
37630     } catch (std::out_of_range& e) {
37631       {
37632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37633       };
37634     } catch (std::exception& e) {
37635       {
37636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37637       };
37638     } catch (Dali::DaliException e) {
37639       {
37640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37641       };
37642     } catch (...) {
37643       {
37644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37645       };
37646     }
37647   }
37648
37649 }
37650
37651
37652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37653   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37654
37655   arg1 = (Dali::Layer *)jarg1;
37656   {
37657     try {
37658       (arg1)->RaiseToTop();
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683
37684   arg1 = (Dali::Layer *)jarg1;
37685   {
37686     try {
37687       (arg1)->LowerToBottom();
37688     } catch (std::out_of_range& e) {
37689       {
37690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37691       };
37692     } catch (std::exception& e) {
37693       {
37694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37695       };
37696     } catch (Dali::DaliException e) {
37697       {
37698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37699       };
37700     } catch (...) {
37701       {
37702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37703       };
37704     }
37705   }
37706
37707 }
37708
37709
37710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37711   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37712   Dali::Layer arg2 ;
37713   Dali::Layer *argp2 ;
37714
37715   arg1 = (Dali::Layer *)jarg1;
37716   argp2 = (Dali::Layer *)jarg2;
37717   if (!argp2) {
37718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37719     return ;
37720   }
37721   arg2 = *argp2;
37722   {
37723     try {
37724       (arg1)->MoveAbove(arg2);
37725     } catch (std::out_of_range& e) {
37726       {
37727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37728       };
37729     } catch (std::exception& e) {
37730       {
37731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37732       };
37733     } catch (Dali::DaliException e) {
37734       {
37735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37736       };
37737     } catch (...) {
37738       {
37739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37740       };
37741     }
37742   }
37743
37744 }
37745
37746
37747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37748   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37749   Dali::Layer arg2 ;
37750   Dali::Layer *argp2 ;
37751
37752   arg1 = (Dali::Layer *)jarg1;
37753   argp2 = (Dali::Layer *)jarg2;
37754   if (!argp2) {
37755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37756     return ;
37757   }
37758   arg2 = *argp2;
37759   {
37760     try {
37761       (arg1)->MoveBelow(arg2);
37762     } catch (std::out_of_range& e) {
37763       {
37764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37765       };
37766     } catch (std::exception& e) {
37767       {
37768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37769       };
37770     } catch (Dali::DaliException e) {
37771       {
37772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37773       };
37774     } catch (...) {
37775       {
37776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37777       };
37778     }
37779   }
37780
37781 }
37782
37783
37784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37785   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37786   Dali::Layer::Behavior arg2 ;
37787
37788   arg1 = (Dali::Layer *)jarg1;
37789   arg2 = (Dali::Layer::Behavior)jarg2;
37790   {
37791     try {
37792       (arg1)->SetBehavior(arg2);
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37800       };
37801     } catch (Dali::DaliException e) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37804       };
37805     } catch (...) {
37806       {
37807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37808       };
37809     }
37810   }
37811
37812 }
37813
37814
37815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37816   int jresult ;
37817   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37818   Dali::Layer::Behavior result;
37819
37820   arg1 = (Dali::Layer *)jarg1;
37821   {
37822     try {
37823       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37824     } catch (std::out_of_range& e) {
37825       {
37826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37827       };
37828     } catch (std::exception& e) {
37829       {
37830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37831       };
37832     } catch (Dali::DaliException e) {
37833       {
37834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37835       };
37836     } catch (...) {
37837       {
37838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37839       };
37840     }
37841   }
37842
37843   jresult = (int)result;
37844   return jresult;
37845 }
37846
37847
37848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37849   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37850   bool arg2 ;
37851
37852   arg1 = (Dali::Layer *)jarg1;
37853   arg2 = jarg2 ? true : false;
37854   {
37855     try {
37856       (arg1)->SetClipping(arg2);
37857     } catch (std::out_of_range& e) {
37858       {
37859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37860       };
37861     } catch (std::exception& e) {
37862       {
37863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37864       };
37865     } catch (Dali::DaliException e) {
37866       {
37867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37868       };
37869     } catch (...) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37872       };
37873     }
37874   }
37875
37876 }
37877
37878
37879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37880   unsigned int jresult ;
37881   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37882   bool result;
37883
37884   arg1 = (Dali::Layer *)jarg1;
37885   {
37886     try {
37887       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37888     } catch (std::out_of_range& e) {
37889       {
37890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37891       };
37892     } catch (std::exception& e) {
37893       {
37894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37895       };
37896     } catch (Dali::DaliException e) {
37897       {
37898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37899       };
37900     } catch (...) {
37901       {
37902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37903       };
37904     }
37905   }
37906
37907   jresult = result;
37908   return jresult;
37909 }
37910
37911
37912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37913   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37914   int arg2 ;
37915   int arg3 ;
37916   int arg4 ;
37917   int arg5 ;
37918
37919   arg1 = (Dali::Layer *)jarg1;
37920   arg2 = (int)jarg2;
37921   arg3 = (int)jarg3;
37922   arg4 = (int)jarg4;
37923   arg5 = (int)jarg5;
37924   {
37925     try {
37926       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37927     } catch (std::out_of_range& e) {
37928       {
37929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37930       };
37931     } catch (std::exception& e) {
37932       {
37933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37934       };
37935     } catch (Dali::DaliException e) {
37936       {
37937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37938       };
37939     } catch (...) {
37940       {
37941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37942       };
37943     }
37944   }
37945
37946 }
37947
37948
37949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37950   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37951   Dali::ClippingBox arg2 ;
37952   Dali::ClippingBox *argp2 ;
37953
37954   arg1 = (Dali::Layer *)jarg1;
37955   argp2 = (Dali::ClippingBox *)jarg2;
37956   if (!argp2) {
37957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37958     return ;
37959   }
37960   arg2 = *argp2;
37961   {
37962     try {
37963       (arg1)->SetClippingBox(arg2);
37964     } catch (std::out_of_range& e) {
37965       {
37966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37967       };
37968     } catch (std::exception& e) {
37969       {
37970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37971       };
37972     } catch (Dali::DaliException e) {
37973       {
37974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37975       };
37976     } catch (...) {
37977       {
37978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37979       };
37980     }
37981   }
37982
37983 }
37984
37985
37986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37987   void * jresult ;
37988   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37989   Dali::ClippingBox result;
37990
37991   arg1 = (Dali::Layer *)jarg1;
37992   {
37993     try {
37994       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37995     } catch (std::out_of_range& e) {
37996       {
37997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37998       };
37999     } catch (std::exception& e) {
38000       {
38001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38002       };
38003     } catch (Dali::DaliException e) {
38004       {
38005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38006       };
38007     } catch (...) {
38008       {
38009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38010       };
38011     }
38012   }
38013
38014   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38015   return jresult;
38016 }
38017
38018
38019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38020   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38021   bool arg2 ;
38022
38023   arg1 = (Dali::Layer *)jarg1;
38024   arg2 = jarg2 ? true : false;
38025   {
38026     try {
38027       (arg1)->SetDepthTestDisabled(arg2);
38028     } catch (std::out_of_range& e) {
38029       {
38030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38031       };
38032     } catch (std::exception& e) {
38033       {
38034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38035       };
38036     } catch (Dali::DaliException e) {
38037       {
38038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38039       };
38040     } catch (...) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38043       };
38044     }
38045   }
38046
38047 }
38048
38049
38050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38051   unsigned int jresult ;
38052   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38053   bool result;
38054
38055   arg1 = (Dali::Layer *)jarg1;
38056   {
38057     try {
38058       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
38059     } catch (std::out_of_range& e) {
38060       {
38061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38062       };
38063     } catch (std::exception& e) {
38064       {
38065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38066       };
38067     } catch (Dali::DaliException e) {
38068       {
38069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38070       };
38071     } catch (...) {
38072       {
38073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38074       };
38075     }
38076   }
38077
38078   jresult = result;
38079   return jresult;
38080 }
38081
38082
38083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38084   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38085   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38086
38087   arg1 = (Dali::Layer *)jarg1;
38088   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38089   {
38090     try {
38091       (arg1)->SetSortFunction(arg2);
38092     } catch (std::out_of_range& e) {
38093       {
38094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38095       };
38096     } catch (std::exception& e) {
38097       {
38098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38099       };
38100     } catch (Dali::DaliException e) {
38101       {
38102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38103       };
38104     } catch (...) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38107       };
38108     }
38109   }
38110
38111 }
38112
38113
38114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38115   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38116   bool arg2 ;
38117
38118   arg1 = (Dali::Layer *)jarg1;
38119   arg2 = jarg2 ? true : false;
38120   {
38121     try {
38122       (arg1)->SetTouchConsumed(arg2);
38123     } catch (std::out_of_range& e) {
38124       {
38125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38126       };
38127     } catch (std::exception& e) {
38128       {
38129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38130       };
38131     } catch (Dali::DaliException e) {
38132       {
38133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38134       };
38135     } catch (...) {
38136       {
38137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38138       };
38139     }
38140   }
38141
38142 }
38143
38144
38145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38146   unsigned int jresult ;
38147   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38148   bool result;
38149
38150   arg1 = (Dali::Layer *)jarg1;
38151   {
38152     try {
38153       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38154     } catch (std::out_of_range& e) {
38155       {
38156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38157       };
38158     } catch (std::exception& e) {
38159       {
38160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38161       };
38162     } catch (Dali::DaliException e) {
38163       {
38164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38165       };
38166     } catch (...) {
38167       {
38168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38169       };
38170     }
38171   }
38172
38173   jresult = result;
38174   return jresult;
38175 }
38176
38177
38178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38179   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38180   bool arg2 ;
38181
38182   arg1 = (Dali::Layer *)jarg1;
38183   arg2 = jarg2 ? true : false;
38184   {
38185     try {
38186       (arg1)->SetHoverConsumed(arg2);
38187     } catch (std::out_of_range& e) {
38188       {
38189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38190       };
38191     } catch (std::exception& e) {
38192       {
38193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38194       };
38195     } catch (Dali::DaliException e) {
38196       {
38197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38198       };
38199     } catch (...) {
38200       {
38201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38202       };
38203     }
38204   }
38205
38206 }
38207
38208
38209 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38210   unsigned int jresult ;
38211   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38212   bool result;
38213
38214   arg1 = (Dali::Layer *)jarg1;
38215   {
38216     try {
38217       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38218     } catch (std::out_of_range& e) {
38219       {
38220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38221       };
38222     } catch (std::exception& e) {
38223       {
38224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38225       };
38226     } catch (Dali::DaliException e) {
38227       {
38228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38229       };
38230     } catch (...) {
38231       {
38232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38233       };
38234     }
38235   }
38236
38237   jresult = result;
38238   return jresult;
38239 }
38240
38241
38242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38243   void * jresult ;
38244   Dali::Vector4 *result = 0 ;
38245
38246   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38247   jresult = (void *)result;
38248   return jresult;
38249 }
38250
38251
38252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38253   void * jresult ;
38254   Dali::Vector4 *result = 0 ;
38255
38256   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38257   jresult = (void *)result;
38258   return jresult;
38259 }
38260
38261
38262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38263   void * jresult ;
38264   Dali::Stage *result = 0 ;
38265
38266   {
38267     try {
38268       result = (Dali::Stage *)new Dali::Stage();
38269     } catch (std::out_of_range& e) {
38270       {
38271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (std::exception& e) {
38274       {
38275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38276       };
38277     } catch (Dali::DaliException e) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38280       };
38281     } catch (...) {
38282       {
38283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38284       };
38285     }
38286   }
38287
38288   jresult = (void *)result;
38289   return jresult;
38290 }
38291
38292
38293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38294   void * jresult ;
38295   Dali::Stage result;
38296
38297   {
38298     try {
38299       result = Dali::Stage::GetCurrent();
38300     } catch (std::out_of_range& e) {
38301       {
38302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38303       };
38304     } catch (std::exception& e) {
38305       {
38306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38307       };
38308     } catch (Dali::DaliException e) {
38309       {
38310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38311       };
38312     } catch (...) {
38313       {
38314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38315       };
38316     }
38317   }
38318
38319   jresult = new Dali::Stage((const Dali::Stage &)result);
38320   return jresult;
38321 }
38322
38323
38324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38325   unsigned int jresult ;
38326   bool result;
38327
38328   {
38329     try {
38330       result = (bool)Dali::Stage::IsInstalled();
38331     } catch (std::out_of_range& e) {
38332       {
38333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38334       };
38335     } catch (std::exception& e) {
38336       {
38337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38338       };
38339     } catch (Dali::DaliException e) {
38340       {
38341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38342       };
38343     } catch (...) {
38344       {
38345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38346       };
38347     }
38348   }
38349
38350   jresult = result;
38351   return jresult;
38352 }
38353
38354
38355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38356   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38357
38358   arg1 = (Dali::Stage *)jarg1;
38359   {
38360     try {
38361       delete arg1;
38362     } catch (std::out_of_range& e) {
38363       {
38364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38365       };
38366     } catch (std::exception& e) {
38367       {
38368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38369       };
38370     } catch (Dali::DaliException e) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38373       };
38374     } catch (...) {
38375       {
38376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38377       };
38378     }
38379   }
38380
38381 }
38382
38383
38384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38385   void * jresult ;
38386   Dali::Stage *arg1 = 0 ;
38387   Dali::Stage *result = 0 ;
38388
38389   arg1 = (Dali::Stage *)jarg1;
38390   if (!arg1) {
38391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38392     return 0;
38393   }
38394   {
38395     try {
38396       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38397     } catch (std::out_of_range& e) {
38398       {
38399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38400       };
38401     } catch (std::exception& e) {
38402       {
38403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38404       };
38405     } catch (Dali::DaliException e) {
38406       {
38407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38408       };
38409     } catch (...) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38412       };
38413     }
38414   }
38415
38416   jresult = (void *)result;
38417   return jresult;
38418 }
38419
38420
38421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38422   void * jresult ;
38423   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38424   Dali::Stage *arg2 = 0 ;
38425   Dali::Stage *result = 0 ;
38426
38427   arg1 = (Dali::Stage *)jarg1;
38428   arg2 = (Dali::Stage *)jarg2;
38429   if (!arg2) {
38430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38431     return 0;
38432   }
38433   {
38434     try {
38435       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38436     } catch (std::out_of_range& e) {
38437       {
38438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (std::exception& e) {
38441       {
38442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38443       };
38444     } catch (Dali::DaliException e) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38447       };
38448     } catch (...) {
38449       {
38450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38451       };
38452     }
38453   }
38454
38455   jresult = (void *)result;
38456   return jresult;
38457 }
38458
38459
38460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38461   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38462   Dali::Actor *arg2 = 0 ;
38463
38464   arg1 = (Dali::Stage *)jarg1;
38465   arg2 = (Dali::Actor *)jarg2;
38466   if (!arg2) {
38467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38468     return ;
38469   }
38470   {
38471     try {
38472       (arg1)->Add(*arg2);
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38488       };
38489     }
38490   }
38491
38492 }
38493
38494
38495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38496   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38497   Dali::Actor *arg2 = 0 ;
38498
38499   arg1 = (Dali::Stage *)jarg1;
38500   arg2 = (Dali::Actor *)jarg2;
38501   if (!arg2) {
38502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38503     return ;
38504   }
38505   {
38506     try {
38507       (arg1)->Remove(*arg2);
38508     } catch (std::out_of_range& e) {
38509       {
38510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38511       };
38512     } catch (std::exception& e) {
38513       {
38514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38515       };
38516     } catch (Dali::DaliException e) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38519       };
38520     } catch (...) {
38521       {
38522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38523       };
38524     }
38525   }
38526
38527 }
38528
38529
38530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38531   void * jresult ;
38532   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38533   Dali::Vector2 result;
38534
38535   arg1 = (Dali::Stage *)jarg1;
38536   {
38537     try {
38538       result = ((Dali::Stage const *)arg1)->GetSize();
38539     } catch (std::out_of_range& e) {
38540       {
38541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38542       };
38543     } catch (std::exception& e) {
38544       {
38545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38546       };
38547     } catch (Dali::DaliException e) {
38548       {
38549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38550       };
38551     } catch (...) {
38552       {
38553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38554       };
38555     }
38556   }
38557
38558   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38559   return jresult;
38560 }
38561
38562
38563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38564   void * jresult ;
38565   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38566   Dali::RenderTaskList result;
38567
38568   arg1 = (Dali::Stage *)jarg1;
38569   {
38570     try {
38571       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38572     } catch (std::out_of_range& e) {
38573       {
38574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38575       };
38576     } catch (std::exception& e) {
38577       {
38578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38579       };
38580     } catch (Dali::DaliException e) {
38581       {
38582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38583       };
38584     } catch (...) {
38585       {
38586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38587       };
38588     }
38589   }
38590
38591   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38592   return jresult;
38593 }
38594
38595
38596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38597   unsigned int jresult ;
38598   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38599   unsigned int result;
38600
38601   arg1 = (Dali::Stage *)jarg1;
38602   {
38603     try {
38604       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38620       };
38621     }
38622   }
38623
38624   jresult = result;
38625   return jresult;
38626 }
38627
38628
38629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38630   void * jresult ;
38631   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38632   unsigned int arg2 ;
38633   Dali::Layer result;
38634
38635   arg1 = (Dali::Stage *)jarg1;
38636   arg2 = (unsigned int)jarg2;
38637   {
38638     try {
38639       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38640     } catch (std::out_of_range& e) {
38641       {
38642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38643       };
38644     } catch (std::exception& e) {
38645       {
38646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (Dali::DaliException e) {
38649       {
38650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38655       };
38656     }
38657   }
38658
38659   jresult = new Dali::Layer((const Dali::Layer &)result);
38660   return jresult;
38661 }
38662
38663
38664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38665   void * jresult ;
38666   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38667   Dali::Layer result;
38668
38669   arg1 = (Dali::Stage *)jarg1;
38670   {
38671     try {
38672       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38673     } catch (std::out_of_range& e) {
38674       {
38675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38676       };
38677     } catch (std::exception& e) {
38678       {
38679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (Dali::DaliException e) {
38682       {
38683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38684       };
38685     } catch (...) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38688       };
38689     }
38690   }
38691
38692   jresult = new Dali::Layer((const Dali::Layer &)result);
38693   return jresult;
38694 }
38695
38696
38697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38698   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38699   Dali::Vector4 arg2 ;
38700   Dali::Vector4 *argp2 ;
38701
38702   arg1 = (Dali::Stage *)jarg1;
38703   argp2 = (Dali::Vector4 *)jarg2;
38704   if (!argp2) {
38705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38706     return ;
38707   }
38708   arg2 = *argp2;
38709   {
38710     try {
38711       (arg1)->SetBackgroundColor(arg2);
38712     } catch (std::out_of_range& e) {
38713       {
38714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38715       };
38716     } catch (std::exception& e) {
38717       {
38718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38719       };
38720     } catch (Dali::DaliException e) {
38721       {
38722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38723       };
38724     } catch (...) {
38725       {
38726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38727       };
38728     }
38729   }
38730
38731 }
38732
38733
38734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38735   void * jresult ;
38736   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38737   Dali::Vector4 result;
38738
38739   arg1 = (Dali::Stage *)jarg1;
38740   {
38741     try {
38742       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38743     } catch (std::out_of_range& e) {
38744       {
38745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38746       };
38747     } catch (std::exception& e) {
38748       {
38749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38750       };
38751     } catch (Dali::DaliException e) {
38752       {
38753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38754       };
38755     } catch (...) {
38756       {
38757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38758       };
38759     }
38760   }
38761
38762   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38763   return jresult;
38764 }
38765
38766
38767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38768   void * jresult ;
38769   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38770   Dali::Vector2 result;
38771
38772   arg1 = (Dali::Stage *)jarg1;
38773   {
38774     try {
38775       result = ((Dali::Stage const *)arg1)->GetDpi();
38776     } catch (std::out_of_range& e) {
38777       {
38778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38779       };
38780     } catch (std::exception& e) {
38781       {
38782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38783       };
38784     } catch (Dali::DaliException e) {
38785       {
38786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38787       };
38788     } catch (...) {
38789       {
38790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38791       };
38792     }
38793   }
38794
38795   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38796   return jresult;
38797 }
38798
38799
38800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38801   void * jresult ;
38802   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38803   Dali::ObjectRegistry result;
38804
38805   arg1 = (Dali::Stage *)jarg1;
38806   {
38807     try {
38808       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38809     } catch (std::out_of_range& e) {
38810       {
38811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38812       };
38813     } catch (std::exception& e) {
38814       {
38815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38816       };
38817     } catch (Dali::DaliException e) {
38818       {
38819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38820       };
38821     } catch (...) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38824       };
38825     }
38826   }
38827
38828   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38829   return jresult;
38830 }
38831
38832
38833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38834   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38835   float arg2 ;
38836
38837   arg1 = (Dali::Stage *)jarg1;
38838   arg2 = (float)jarg2;
38839   {
38840     try {
38841       (arg1)->KeepRendering(arg2);
38842     } catch (std::out_of_range& e) {
38843       {
38844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38845       };
38846     } catch (std::exception& e) {
38847       {
38848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38849       };
38850     } catch (Dali::DaliException e) {
38851       {
38852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38853       };
38854     } catch (...) {
38855       {
38856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38857       };
38858     }
38859   }
38860
38861 }
38862
38863
38864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38865   void * jresult ;
38866   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38867   Dali::Stage::KeyEventSignalType *result = 0 ;
38868
38869   arg1 = (Dali::Stage *)jarg1;
38870   {
38871     try {
38872       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38873     } catch (std::out_of_range& e) {
38874       {
38875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38876       };
38877     } catch (std::exception& e) {
38878       {
38879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (Dali::DaliException e) {
38882       {
38883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38884       };
38885     } catch (...) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38888       };
38889     }
38890   }
38891
38892   jresult = (void *)result;
38893   return jresult;
38894 }
38895
38896
38897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38898   void * jresult ;
38899   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38900   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38901
38902   arg1 = (Dali::Stage *)jarg1;
38903   {
38904     try {
38905       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38906     } catch (std::out_of_range& e) {
38907       {
38908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38909       };
38910     } catch (std::exception& e) {
38911       {
38912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (Dali::DaliException e) {
38915       {
38916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38917       };
38918     } catch (...) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38921       };
38922     }
38923   }
38924
38925   jresult = (void *)result;
38926   return jresult;
38927 }
38928
38929
38930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38931   void * jresult ;
38932   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38933   Dali::Stage::TouchSignalType *result = 0 ;
38934
38935   arg1 = (Dali::Stage *)jarg1;
38936   {
38937     try {
38938       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38939     } catch (std::out_of_range& e) {
38940       {
38941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38942       };
38943     } catch (std::exception& e) {
38944       {
38945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (Dali::DaliException e) {
38948       {
38949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38954       };
38955     }
38956   }
38957
38958   jresult = (void *)result;
38959   return jresult;
38960 }
38961
38962
38963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38964   void * jresult ;
38965   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38966   Dali::Stage::WheelEventSignalType *result = 0 ;
38967
38968   arg1 = (Dali::Stage *)jarg1;
38969   {
38970     try {
38971       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38972     } catch (std::out_of_range& e) {
38973       {
38974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38975       };
38976     } catch (std::exception& e) {
38977       {
38978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (Dali::DaliException e) {
38981       {
38982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38983       };
38984     } catch (...) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38987       };
38988     }
38989   }
38990
38991   jresult = (void *)result;
38992   return jresult;
38993 }
38994
38995
38996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38997   void * jresult ;
38998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38999   Dali::Stage::ContextStatusSignal *result = 0 ;
39000
39001   arg1 = (Dali::Stage *)jarg1;
39002   {
39003     try {
39004       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39005     } catch (std::out_of_range& e) {
39006       {
39007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39008       };
39009     } catch (std::exception& e) {
39010       {
39011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39012       };
39013     } catch (Dali::DaliException e) {
39014       {
39015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39016       };
39017     } catch (...) {
39018       {
39019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39020       };
39021     }
39022   }
39023
39024   jresult = (void *)result;
39025   return jresult;
39026 }
39027
39028
39029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39030   void * jresult ;
39031   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39032   Dali::Stage::ContextStatusSignal *result = 0 ;
39033
39034   arg1 = (Dali::Stage *)jarg1;
39035   {
39036     try {
39037       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39038     } catch (std::out_of_range& e) {
39039       {
39040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39041       };
39042     } catch (std::exception& e) {
39043       {
39044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39045       };
39046     } catch (Dali::DaliException e) {
39047       {
39048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39049       };
39050     } catch (...) {
39051       {
39052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39053       };
39054     }
39055   }
39056
39057   jresult = (void *)result;
39058   return jresult;
39059 }
39060
39061
39062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39063   void * jresult ;
39064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39065   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39066
39067   arg1 = (Dali::Stage *)jarg1;
39068   {
39069     try {
39070       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39071     } catch (std::out_of_range& e) {
39072       {
39073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (std::exception& e) {
39076       {
39077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39078       };
39079     } catch (Dali::DaliException e) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39082       };
39083     } catch (...) {
39084       {
39085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39086       };
39087     }
39088   }
39089
39090   jresult = (void *)result;
39091   return jresult;
39092 }
39093
39094
39095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39096   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39097
39098   arg1 = (Dali::RelayoutContainer *)jarg1;
39099   {
39100     try {
39101       delete arg1;
39102     } catch (std::out_of_range& e) {
39103       {
39104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39105       };
39106     } catch (std::exception& e) {
39107       {
39108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39109       };
39110     } catch (Dali::DaliException e) {
39111       {
39112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39113       };
39114     } catch (...) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39117       };
39118     }
39119   }
39120
39121 }
39122
39123
39124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39125   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39126   Dali::Actor *arg2 = 0 ;
39127   Dali::Vector2 *arg3 = 0 ;
39128
39129   arg1 = (Dali::RelayoutContainer *)jarg1;
39130   arg2 = (Dali::Actor *)jarg2;
39131   if (!arg2) {
39132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39133     return ;
39134   }
39135   arg3 = (Dali::Vector2 *)jarg3;
39136   if (!arg3) {
39137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39138     return ;
39139   }
39140   {
39141     try {
39142       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39143     } catch (std::out_of_range& e) {
39144       {
39145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39146       };
39147     } catch (std::exception& e) {
39148       {
39149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39150       };
39151     } catch (Dali::DaliException e) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39154       };
39155     } catch (...) {
39156       {
39157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39158       };
39159     }
39160   }
39161
39162 }
39163
39164
39165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39166   void * jresult ;
39167   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39168   Dali::CustomActor result;
39169
39170   arg1 = (Dali::CustomActorImpl *)jarg1;
39171   {
39172     try {
39173       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39181       };
39182     } catch (Dali::DaliException e) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39189       };
39190     }
39191   }
39192
39193   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39194   return jresult;
39195 }
39196
39197
39198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39199   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39200   int arg2 ;
39201
39202   arg1 = (Dali::CustomActorImpl *)jarg1;
39203   arg2 = (int)jarg2;
39204   {
39205     try {
39206       (arg1)->OnStageConnection(arg2);
39207     } catch (std::out_of_range& e) {
39208       {
39209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39210       };
39211     } catch (std::exception& e) {
39212       {
39213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39214       };
39215     } catch (Dali::DaliException e) {
39216       {
39217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39218       };
39219     } catch (...) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39222       };
39223     }
39224   }
39225
39226 }
39227
39228
39229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39230   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39231
39232   arg1 = (Dali::CustomActorImpl *)jarg1;
39233   {
39234     try {
39235       (arg1)->OnStageDisconnection();
39236     } catch (std::out_of_range& e) {
39237       {
39238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39239       };
39240     } catch (std::exception& e) {
39241       {
39242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39243       };
39244     } catch (Dali::DaliException e) {
39245       {
39246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39247       };
39248     } catch (...) {
39249       {
39250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39251       };
39252     }
39253   }
39254
39255 }
39256
39257
39258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39259   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39260   Dali::Actor *arg2 = 0 ;
39261
39262   arg1 = (Dali::CustomActorImpl *)jarg1;
39263   arg2 = (Dali::Actor *)jarg2;
39264   if (!arg2) {
39265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39266     return ;
39267   }
39268   {
39269     try {
39270       (arg1)->OnChildAdd(*arg2);
39271     } catch (std::out_of_range& e) {
39272       {
39273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39274       };
39275     } catch (std::exception& e) {
39276       {
39277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39278       };
39279     } catch (Dali::DaliException e) {
39280       {
39281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39282       };
39283     } catch (...) {
39284       {
39285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39286       };
39287     }
39288   }
39289
39290 }
39291
39292
39293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39294   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39295   Dali::Actor *arg2 = 0 ;
39296
39297   arg1 = (Dali::CustomActorImpl *)jarg1;
39298   arg2 = (Dali::Actor *)jarg2;
39299   if (!arg2) {
39300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39301     return ;
39302   }
39303   {
39304     try {
39305       (arg1)->OnChildRemove(*arg2);
39306     } catch (std::out_of_range& e) {
39307       {
39308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (std::exception& e) {
39311       {
39312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39313       };
39314     } catch (Dali::DaliException e) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39317       };
39318     } catch (...) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39321       };
39322     }
39323   }
39324
39325 }
39326
39327
39328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39329   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39330   Dali::Property::Index arg2 ;
39331   Dali::Property::Value arg3 ;
39332   Dali::Property::Value *argp3 ;
39333
39334   arg1 = (Dali::CustomActorImpl *)jarg1;
39335   arg2 = (Dali::Property::Index)jarg2;
39336   argp3 = (Dali::Property::Value *)jarg3;
39337   if (!argp3) {
39338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39339     return ;
39340   }
39341   arg3 = *argp3;
39342   {
39343     try {
39344       (arg1)->OnPropertySet(arg2,arg3);
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39352       };
39353     } catch (Dali::DaliException e) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39360       };
39361     }
39362   }
39363
39364 }
39365
39366
39367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39368   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39369   Dali::Vector3 *arg2 = 0 ;
39370
39371   arg1 = (Dali::CustomActorImpl *)jarg1;
39372   arg2 = (Dali::Vector3 *)jarg2;
39373   if (!arg2) {
39374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39375     return ;
39376   }
39377   {
39378     try {
39379       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39380     } catch (std::out_of_range& e) {
39381       {
39382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39383       };
39384     } catch (std::exception& e) {
39385       {
39386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39387       };
39388     } catch (Dali::DaliException e) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39391       };
39392     } catch (...) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39395       };
39396     }
39397   }
39398
39399 }
39400
39401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39402   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39403   Dali::Animation *arg2 = 0 ;
39404   Dali::Vector3 *arg3 = 0 ;
39405
39406   arg1 = (Dali::CustomActorImpl *)jarg1;
39407   arg2 = (Dali::Animation *)jarg2;
39408   if (!arg2) {
39409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39410     return ;
39411   }
39412   arg3 = (Dali::Vector3 *)jarg3;
39413   if (!arg3) {
39414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39415     return ;
39416   }
39417   {
39418     try {
39419       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39420     } catch (std::out_of_range& e) {
39421       {
39422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39423       };
39424     } catch (std::exception& e) {
39425       {
39426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39427       };
39428     } catch (Dali::DaliException e) {
39429       {
39430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39431       };
39432     } catch (...) {
39433       {
39434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39435       };
39436     }
39437   }
39438
39439 }
39440
39441
39442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39443   unsigned int jresult ;
39444   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39445   Dali::TouchEvent *arg2 = 0 ;
39446   bool result;
39447
39448   arg1 = (Dali::CustomActorImpl *)jarg1;
39449   arg2 = (Dali::TouchEvent *)jarg2;
39450   if (!arg2) {
39451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39452     return 0;
39453   }
39454   {
39455     try {
39456       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39457     } catch (std::out_of_range& e) {
39458       {
39459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39460       };
39461     } catch (std::exception& e) {
39462       {
39463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39464       };
39465     } catch (Dali::DaliException e) {
39466       {
39467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39468       };
39469     } catch (...) {
39470       {
39471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39472       };
39473     }
39474   }
39475
39476   jresult = result;
39477   return jresult;
39478 }
39479
39480
39481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39482   unsigned int jresult ;
39483   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39484   Dali::HoverEvent *arg2 = 0 ;
39485   bool result;
39486
39487   arg1 = (Dali::CustomActorImpl *)jarg1;
39488   arg2 = (Dali::HoverEvent *)jarg2;
39489   if (!arg2) {
39490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39491     return 0;
39492   }
39493   {
39494     try {
39495       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39496     } catch (std::out_of_range& e) {
39497       {
39498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39499       };
39500     } catch (std::exception& e) {
39501       {
39502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39503       };
39504     } catch (Dali::DaliException e) {
39505       {
39506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39507       };
39508     } catch (...) {
39509       {
39510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39511       };
39512     }
39513   }
39514
39515   jresult = result;
39516   return jresult;
39517 }
39518
39519
39520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39521   unsigned int jresult ;
39522   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39523   Dali::KeyEvent *arg2 = 0 ;
39524   bool result;
39525
39526   arg1 = (Dali::CustomActorImpl *)jarg1;
39527   arg2 = (Dali::KeyEvent *)jarg2;
39528   if (!arg2) {
39529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39530     return 0;
39531   }
39532   {
39533     try {
39534       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39535     } catch (std::out_of_range& e) {
39536       {
39537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39538       };
39539     } catch (std::exception& e) {
39540       {
39541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39542       };
39543     } catch (Dali::DaliException e) {
39544       {
39545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39546       };
39547     } catch (...) {
39548       {
39549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39550       };
39551     }
39552   }
39553
39554   jresult = result;
39555   return jresult;
39556 }
39557
39558
39559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39560   unsigned int jresult ;
39561   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39562   Dali::WheelEvent *arg2 = 0 ;
39563   bool result;
39564
39565   arg1 = (Dali::CustomActorImpl *)jarg1;
39566   arg2 = (Dali::WheelEvent *)jarg2;
39567   if (!arg2) {
39568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39569     return 0;
39570   }
39571   {
39572     try {
39573       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39574     } catch (std::out_of_range& e) {
39575       {
39576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39577       };
39578     } catch (std::exception& e) {
39579       {
39580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39581       };
39582     } catch (Dali::DaliException e) {
39583       {
39584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39585       };
39586     } catch (...) {
39587       {
39588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39589       };
39590     }
39591   }
39592
39593   jresult = result;
39594   return jresult;
39595 }
39596
39597
39598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39599   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39600   Dali::Vector2 *arg2 = 0 ;
39601   Dali::RelayoutContainer *arg3 = 0 ;
39602
39603   arg1 = (Dali::CustomActorImpl *)jarg1;
39604   arg2 = (Dali::Vector2 *)jarg2;
39605   if (!arg2) {
39606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39607     return ;
39608   }
39609   arg3 = (Dali::RelayoutContainer *)jarg3;
39610   if (!arg3) {
39611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39612     return ;
39613   }
39614   {
39615     try {
39616       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39617     } catch (std::out_of_range& e) {
39618       {
39619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39620       };
39621     } catch (std::exception& e) {
39622       {
39623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39624       };
39625     } catch (Dali::DaliException e) {
39626       {
39627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39628       };
39629     } catch (...) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39632       };
39633     }
39634   }
39635
39636 }
39637
39638
39639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39640   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39641   Dali::ResizePolicy::Type arg2 ;
39642   Dali::Dimension::Type arg3 ;
39643
39644   arg1 = (Dali::CustomActorImpl *)jarg1;
39645   arg2 = (Dali::ResizePolicy::Type)jarg2;
39646   arg3 = (Dali::Dimension::Type)jarg3;
39647   {
39648     try {
39649       (arg1)->OnSetResizePolicy(arg2,arg3);
39650     } catch (std::out_of_range& e) {
39651       {
39652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39653       };
39654     } catch (std::exception& e) {
39655       {
39656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39657       };
39658     } catch (Dali::DaliException e) {
39659       {
39660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39661       };
39662     } catch (...) {
39663       {
39664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39665       };
39666     }
39667   }
39668
39669 }
39670
39671
39672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39673   void * jresult ;
39674   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39675   Dali::Vector3 result;
39676
39677   arg1 = (Dali::CustomActorImpl *)jarg1;
39678   {
39679     try {
39680       result = (arg1)->GetNaturalSize();
39681     } catch (std::out_of_range& e) {
39682       {
39683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39684       };
39685     } catch (std::exception& e) {
39686       {
39687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39688       };
39689     } catch (Dali::DaliException e) {
39690       {
39691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39692       };
39693     } catch (...) {
39694       {
39695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39696       };
39697     }
39698   }
39699
39700   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39701   return jresult;
39702 }
39703
39704
39705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39706   float jresult ;
39707   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39708   Dali::Actor *arg2 = 0 ;
39709   Dali::Dimension::Type arg3 ;
39710   float result;
39711
39712   arg1 = (Dali::CustomActorImpl *)jarg1;
39713   arg2 = (Dali::Actor *)jarg2;
39714   if (!arg2) {
39715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39716     return 0;
39717   }
39718   arg3 = (Dali::Dimension::Type)jarg3;
39719   {
39720     try {
39721       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39722     } catch (std::out_of_range& e) {
39723       {
39724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39725       };
39726     } catch (std::exception& e) {
39727       {
39728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39729       };
39730     } catch (Dali::DaliException e) {
39731       {
39732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39733       };
39734     } catch (...) {
39735       {
39736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39737       };
39738     }
39739   }
39740
39741   jresult = result;
39742   return jresult;
39743 }
39744
39745
39746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39747   float jresult ;
39748   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39749   float arg2 ;
39750   float result;
39751
39752   arg1 = (Dali::CustomActorImpl *)jarg1;
39753   arg2 = (float)jarg2;
39754   {
39755     try {
39756       result = (float)(arg1)->GetHeightForWidth(arg2);
39757     } catch (std::out_of_range& e) {
39758       {
39759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39760       };
39761     } catch (std::exception& e) {
39762       {
39763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39764       };
39765     } catch (Dali::DaliException e) {
39766       {
39767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39768       };
39769     } catch (...) {
39770       {
39771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39772       };
39773     }
39774   }
39775
39776   jresult = result;
39777   return jresult;
39778 }
39779
39780
39781 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39782   float jresult ;
39783   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39784   float arg2 ;
39785   float result;
39786
39787   arg1 = (Dali::CustomActorImpl *)jarg1;
39788   arg2 = (float)jarg2;
39789   {
39790     try {
39791       result = (float)(arg1)->GetWidthForHeight(arg2);
39792     } catch (std::out_of_range& e) {
39793       {
39794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39795       };
39796     } catch (std::exception& e) {
39797       {
39798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39799       };
39800     } catch (Dali::DaliException e) {
39801       {
39802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39803       };
39804     } catch (...) {
39805       {
39806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39807       };
39808     }
39809   }
39810
39811   jresult = result;
39812   return jresult;
39813 }
39814
39815
39816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39817   unsigned int jresult ;
39818   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39819   Dali::Dimension::Type arg2 ;
39820   bool result;
39821
39822   arg1 = (Dali::CustomActorImpl *)jarg1;
39823   arg2 = (Dali::Dimension::Type)jarg2;
39824   {
39825     try {
39826       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39827     } catch (std::out_of_range& e) {
39828       {
39829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39830       };
39831     } catch (std::exception& e) {
39832       {
39833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39834       };
39835     } catch (Dali::DaliException e) {
39836       {
39837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39838       };
39839     } catch (...) {
39840       {
39841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39842       };
39843     }
39844   }
39845
39846   jresult = result;
39847   return jresult;
39848 }
39849
39850
39851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39852   unsigned int jresult ;
39853   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39854   bool result;
39855
39856   arg1 = (Dali::CustomActorImpl *)jarg1;
39857   {
39858     try {
39859       result = (bool)(arg1)->RelayoutDependentOnChildren();
39860     } catch (std::out_of_range& e) {
39861       {
39862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (std::exception& e) {
39865       {
39866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39867       };
39868     } catch (Dali::DaliException e) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39871       };
39872     } catch (...) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39875       };
39876     }
39877   }
39878
39879   jresult = result;
39880   return jresult;
39881 }
39882
39883
39884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39885   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39886   Dali::Dimension::Type arg2 ;
39887
39888   arg1 = (Dali::CustomActorImpl *)jarg1;
39889   arg2 = (Dali::Dimension::Type)jarg2;
39890   {
39891     try {
39892       (arg1)->OnCalculateRelayoutSize(arg2);
39893     } catch (std::out_of_range& e) {
39894       {
39895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39896       };
39897     } catch (std::exception& e) {
39898       {
39899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39900       };
39901     } catch (Dali::DaliException e) {
39902       {
39903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39904       };
39905     } catch (...) {
39906       {
39907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39908       };
39909     }
39910   }
39911
39912 }
39913
39914
39915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39916   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39917   float arg2 ;
39918   Dali::Dimension::Type arg3 ;
39919
39920   arg1 = (Dali::CustomActorImpl *)jarg1;
39921   arg2 = (float)jarg2;
39922   arg3 = (Dali::Dimension::Type)jarg3;
39923   {
39924     try {
39925       (arg1)->OnLayoutNegotiated(arg2,arg3);
39926     } catch (std::out_of_range& e) {
39927       {
39928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39929       };
39930     } catch (std::exception& e) {
39931       {
39932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39933       };
39934     } catch (Dali::DaliException e) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39937       };
39938     } catch (...) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39941       };
39942     }
39943   }
39944
39945 }
39946
39947
39948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39949   unsigned int jresult ;
39950   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39951   bool result;
39952
39953   arg1 = (Dali::CustomActorImpl *)jarg1;
39954   {
39955     try {
39956       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39957     } catch (std::out_of_range& e) {
39958       {
39959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39960       };
39961     } catch (std::exception& e) {
39962       {
39963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39964       };
39965     } catch (Dali::DaliException e) {
39966       {
39967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39968       };
39969     } catch (...) {
39970       {
39971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39972       };
39973     }
39974   }
39975
39976   jresult = result;
39977   return jresult;
39978 }
39979
39980
39981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39982   unsigned int jresult ;
39983   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39984   bool result;
39985
39986   arg1 = (Dali::CustomActorImpl *)jarg1;
39987   {
39988     try {
39989       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39990     } catch (std::out_of_range& e) {
39991       {
39992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (std::exception& e) {
39995       {
39996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (Dali::DaliException e) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40005       };
40006     }
40007   }
40008
40009   jresult = result;
40010   return jresult;
40011 }
40012
40013
40014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40015   unsigned int jresult ;
40016   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40017   bool result;
40018
40019   arg1 = (Dali::CustomActorImpl *)jarg1;
40020   {
40021     try {
40022       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (Dali::DaliException e) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40034       };
40035     } catch (...) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40038       };
40039     }
40040   }
40041
40042   jresult = result;
40043   return jresult;
40044 }
40045
40046
40047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40048   unsigned int jresult ;
40049   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40050   bool result;
40051
40052   arg1 = (Dali::CustomActorImpl *)jarg1;
40053   {
40054     try {
40055       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40056     } catch (std::out_of_range& e) {
40057       {
40058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40059       };
40060     } catch (std::exception& e) {
40061       {
40062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40063       };
40064     } catch (Dali::DaliException e) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40067       };
40068     } catch (...) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40071       };
40072     }
40073   }
40074
40075   jresult = result;
40076   return jresult;
40077 }
40078
40079
40080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40081   void * jresult ;
40082   Dali::CustomActor *result = 0 ;
40083
40084   {
40085     try {
40086       result = (Dali::CustomActor *)new Dali::CustomActor();
40087     } catch (std::out_of_range& e) {
40088       {
40089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40090       };
40091     } catch (std::exception& e) {
40092       {
40093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40094       };
40095     } catch (Dali::DaliException e) {
40096       {
40097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40098       };
40099     } catch (...) {
40100       {
40101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40102       };
40103     }
40104   }
40105
40106   jresult = (void *)result;
40107   return jresult;
40108 }
40109
40110
40111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40112   void * jresult ;
40113   Dali::BaseHandle arg1 ;
40114   Dali::BaseHandle *argp1 ;
40115   Dali::CustomActor result;
40116
40117   argp1 = (Dali::BaseHandle *)jarg1;
40118   if (!argp1) {
40119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40120     return 0;
40121   }
40122   arg1 = *argp1;
40123   {
40124     try {
40125       result = Dali::CustomActor::DownCast(arg1);
40126     } catch (std::out_of_range& e) {
40127       {
40128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40129       };
40130     } catch (std::exception& e) {
40131       {
40132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40133       };
40134     } catch (Dali::DaliException e) {
40135       {
40136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40137       };
40138     } catch (...) {
40139       {
40140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40141       };
40142     }
40143   }
40144
40145   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40146   return jresult;
40147 }
40148
40149
40150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40151   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40152
40153   arg1 = (Dali::CustomActor *)jarg1;
40154   {
40155     try {
40156       delete arg1;
40157     } catch (std::out_of_range& e) {
40158       {
40159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40160       };
40161     } catch (std::exception& e) {
40162       {
40163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40164       };
40165     } catch (Dali::DaliException e) {
40166       {
40167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40168       };
40169     } catch (...) {
40170       {
40171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40172       };
40173     }
40174   }
40175
40176 }
40177
40178
40179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40180   void * jresult ;
40181   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40182   Dali::CustomActorImpl *result = 0 ;
40183
40184   arg1 = (Dali::CustomActor *)jarg1;
40185   {
40186     try {
40187       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40188     } catch (std::out_of_range& e) {
40189       {
40190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40191       };
40192     } catch (std::exception& e) {
40193       {
40194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40195       };
40196     } catch (Dali::DaliException e) {
40197       {
40198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40199       };
40200     } catch (...) {
40201       {
40202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40203       };
40204     }
40205   }
40206
40207   jresult = (void *)result;
40208   return jresult;
40209 }
40210
40211
40212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40213   void * jresult ;
40214   Dali::CustomActorImpl *arg1 = 0 ;
40215   Dali::CustomActor *result = 0 ;
40216
40217   arg1 = (Dali::CustomActorImpl *)jarg1;
40218   if (!arg1) {
40219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40220     return 0;
40221   }
40222   {
40223     try {
40224       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40225     } catch (std::out_of_range& e) {
40226       {
40227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40228       };
40229     } catch (std::exception& e) {
40230       {
40231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40232       };
40233     } catch (Dali::DaliException e) {
40234       {
40235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40236       };
40237     } catch (...) {
40238       {
40239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40240       };
40241     }
40242   }
40243
40244   jresult = (void *)result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40250   void * jresult ;
40251   Dali::CustomActor *arg1 = 0 ;
40252   Dali::CustomActor *result = 0 ;
40253
40254   arg1 = (Dali::CustomActor *)jarg1;
40255   if (!arg1) {
40256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40257     return 0;
40258   }
40259   {
40260     try {
40261       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40262     } catch (std::out_of_range& e) {
40263       {
40264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40265       };
40266     } catch (std::exception& e) {
40267       {
40268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40269       };
40270     } catch (Dali::DaliException e) {
40271       {
40272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40273       };
40274     } catch (...) {
40275       {
40276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40277       };
40278     }
40279   }
40280
40281   jresult = (void *)result;
40282   return jresult;
40283 }
40284
40285
40286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40287   void * jresult ;
40288   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40289   Dali::CustomActor *arg2 = 0 ;
40290   Dali::CustomActor *result = 0 ;
40291
40292   arg1 = (Dali::CustomActor *)jarg1;
40293   arg2 = (Dali::CustomActor *)jarg2;
40294   if (!arg2) {
40295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40296     return 0;
40297   }
40298   {
40299     try {
40300       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40301     } catch (std::out_of_range& e) {
40302       {
40303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40304       };
40305     } catch (std::exception& e) {
40306       {
40307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40308       };
40309     } catch (Dali::DaliException e) {
40310       {
40311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40312       };
40313     } catch (...) {
40314       {
40315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40316       };
40317     }
40318   }
40319
40320   jresult = (void *)result;
40321   return jresult;
40322 }
40323
40324
40325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40326   int jresult ;
40327   int result;
40328
40329   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40330   jresult = (int)result;
40331   return jresult;
40332 }
40333
40334
40335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40336   int jresult ;
40337   int result;
40338
40339   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40340   jresult = (int)result;
40341   return jresult;
40342 }
40343
40344
40345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40346   int jresult ;
40347   int result;
40348
40349   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40350   jresult = (int)result;
40351   return jresult;
40352 }
40353
40354
40355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40356   int jresult ;
40357   int result;
40358
40359   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40360   jresult = (int)result;
40361   return jresult;
40362 }
40363
40364
40365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40366   int jresult ;
40367   int result;
40368
40369   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40370   jresult = (int)result;
40371   return jresult;
40372 }
40373
40374
40375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40376   int jresult ;
40377   int result;
40378
40379   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40380   jresult = (int)result;
40381   return jresult;
40382 }
40383
40384
40385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40386   int jresult ;
40387   int result;
40388
40389   result = (int)Dali::PanGestureDetector::Property::PANNING;
40390   jresult = (int)result;
40391   return jresult;
40392 }
40393
40394
40395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40396   void * jresult ;
40397   Dali::PanGestureDetector::Property *result = 0 ;
40398
40399   {
40400     try {
40401       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40402     } catch (std::out_of_range& e) {
40403       {
40404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40405       };
40406     } catch (std::exception& e) {
40407       {
40408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40409       };
40410     } catch (Dali::DaliException e) {
40411       {
40412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40413       };
40414     } catch (...) {
40415       {
40416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40417       };
40418     }
40419   }
40420
40421   jresult = (void *)result;
40422   return jresult;
40423 }
40424
40425
40426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40427   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40428
40429   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40430   {
40431     try {
40432       delete arg1;
40433     } catch (std::out_of_range& e) {
40434       {
40435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40436       };
40437     } catch (std::exception& e) {
40438       {
40439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40440       };
40441     } catch (Dali::DaliException e) {
40442       {
40443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40444       };
40445     } catch (...) {
40446       {
40447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40448       };
40449     }
40450   }
40451
40452 }
40453
40454
40455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40456   void * jresult ;
40457   Dali::Radian *result = 0 ;
40458
40459   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40460   jresult = (void *)result;
40461   return jresult;
40462 }
40463
40464
40465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40466   void * jresult ;
40467   Dali::Radian *result = 0 ;
40468
40469   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40470   jresult = (void *)result;
40471   return jresult;
40472 }
40473
40474
40475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40476   void * jresult ;
40477   Dali::Radian *result = 0 ;
40478
40479   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40480   jresult = (void *)result;
40481   return jresult;
40482 }
40483
40484
40485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40486   void * jresult ;
40487   Dali::Radian *result = 0 ;
40488
40489   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40490   jresult = (void *)result;
40491   return jresult;
40492 }
40493
40494
40495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40496   void * jresult ;
40497   Dali::Radian *result = 0 ;
40498
40499   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40500   jresult = (void *)result;
40501   return jresult;
40502 }
40503
40504
40505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40506   void * jresult ;
40507   Dali::Radian *result = 0 ;
40508
40509   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40510   jresult = (void *)result;
40511   return jresult;
40512 }
40513
40514
40515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40516   void * jresult ;
40517   Dali::Radian *result = 0 ;
40518
40519   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40520   jresult = (void *)result;
40521   return jresult;
40522 }
40523
40524
40525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40526   void * jresult ;
40527   Dali::PanGestureDetector *result = 0 ;
40528
40529   {
40530     try {
40531       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40532     } catch (std::out_of_range& e) {
40533       {
40534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40535       };
40536     } catch (std::exception& e) {
40537       {
40538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40539       };
40540     } catch (Dali::DaliException e) {
40541       {
40542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40543       };
40544     } catch (...) {
40545       {
40546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40547       };
40548     }
40549   }
40550
40551   jresult = (void *)result;
40552   return jresult;
40553 }
40554
40555
40556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40557   void * jresult ;
40558   Dali::PanGestureDetector result;
40559
40560   {
40561     try {
40562       result = Dali::PanGestureDetector::New();
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40578       };
40579     }
40580   }
40581
40582   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40583   return jresult;
40584 }
40585
40586
40587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40588   void * jresult ;
40589   Dali::BaseHandle arg1 ;
40590   Dali::BaseHandle *argp1 ;
40591   Dali::PanGestureDetector result;
40592
40593   argp1 = (Dali::BaseHandle *)jarg1;
40594   if (!argp1) {
40595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40596     return 0;
40597   }
40598   arg1 = *argp1;
40599   {
40600     try {
40601       result = Dali::PanGestureDetector::DownCast(arg1);
40602     } catch (std::out_of_range& e) {
40603       {
40604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40605       };
40606     } catch (std::exception& e) {
40607       {
40608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40609       };
40610     } catch (Dali::DaliException e) {
40611       {
40612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40613       };
40614     } catch (...) {
40615       {
40616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40617       };
40618     }
40619   }
40620
40621   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40622   return jresult;
40623 }
40624
40625
40626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40627   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40628
40629   arg1 = (Dali::PanGestureDetector *)jarg1;
40630   {
40631     try {
40632       delete arg1;
40633     } catch (std::out_of_range& e) {
40634       {
40635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40636       };
40637     } catch (std::exception& e) {
40638       {
40639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40640       };
40641     } catch (Dali::DaliException e) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40644       };
40645     } catch (...) {
40646       {
40647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40648       };
40649     }
40650   }
40651
40652 }
40653
40654
40655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40656   void * jresult ;
40657   Dali::PanGestureDetector *arg1 = 0 ;
40658   Dali::PanGestureDetector *result = 0 ;
40659
40660   arg1 = (Dali::PanGestureDetector *)jarg1;
40661   if (!arg1) {
40662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40663     return 0;
40664   }
40665   {
40666     try {
40667       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40668     } catch (std::out_of_range& e) {
40669       {
40670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40671       };
40672     } catch (std::exception& e) {
40673       {
40674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40675       };
40676     } catch (Dali::DaliException e) {
40677       {
40678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40679       };
40680     } catch (...) {
40681       {
40682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40683       };
40684     }
40685   }
40686
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40693   void * jresult ;
40694   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40695   Dali::PanGestureDetector *arg2 = 0 ;
40696   Dali::PanGestureDetector *result = 0 ;
40697
40698   arg1 = (Dali::PanGestureDetector *)jarg1;
40699   arg2 = (Dali::PanGestureDetector *)jarg2;
40700   if (!arg2) {
40701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40702     return 0;
40703   }
40704   {
40705     try {
40706       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40707     } catch (std::out_of_range& e) {
40708       {
40709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40710       };
40711     } catch (std::exception& e) {
40712       {
40713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40714       };
40715     } catch (Dali::DaliException e) {
40716       {
40717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40718       };
40719     } catch (...) {
40720       {
40721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40722       };
40723     }
40724   }
40725
40726   jresult = (void *)result;
40727   return jresult;
40728 }
40729
40730
40731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40732   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40733   unsigned int arg2 ;
40734
40735   arg1 = (Dali::PanGestureDetector *)jarg1;
40736   arg2 = (unsigned int)jarg2;
40737   {
40738     try {
40739       (arg1)->SetMinimumTouchesRequired(arg2);
40740     } catch (std::out_of_range& e) {
40741       {
40742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40743       };
40744     } catch (std::exception& e) {
40745       {
40746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40747       };
40748     } catch (Dali::DaliException e) {
40749       {
40750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40751       };
40752     } catch (...) {
40753       {
40754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40755       };
40756     }
40757   }
40758
40759 }
40760
40761
40762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40763   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40764   unsigned int arg2 ;
40765
40766   arg1 = (Dali::PanGestureDetector *)jarg1;
40767   arg2 = (unsigned int)jarg2;
40768   {
40769     try {
40770       (arg1)->SetMaximumTouchesRequired(arg2);
40771     } catch (std::out_of_range& e) {
40772       {
40773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40774       };
40775     } catch (std::exception& e) {
40776       {
40777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40778       };
40779     } catch (Dali::DaliException e) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40782       };
40783     } catch (...) {
40784       {
40785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40786       };
40787     }
40788   }
40789
40790 }
40791
40792
40793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40794   unsigned int jresult ;
40795   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40796   unsigned int result;
40797
40798   arg1 = (Dali::PanGestureDetector *)jarg1;
40799   {
40800     try {
40801       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40802     } catch (std::out_of_range& e) {
40803       {
40804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40805       };
40806     } catch (std::exception& e) {
40807       {
40808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40809       };
40810     } catch (Dali::DaliException e) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40813       };
40814     } catch (...) {
40815       {
40816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40817       };
40818     }
40819   }
40820
40821   jresult = result;
40822   return jresult;
40823 }
40824
40825
40826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40827   unsigned int jresult ;
40828   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40829   unsigned int result;
40830
40831   arg1 = (Dali::PanGestureDetector *)jarg1;
40832   {
40833     try {
40834       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40835     } catch (std::out_of_range& e) {
40836       {
40837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40838       };
40839     } catch (std::exception& e) {
40840       {
40841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40842       };
40843     } catch (Dali::DaliException e) {
40844       {
40845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40846       };
40847     } catch (...) {
40848       {
40849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40850       };
40851     }
40852   }
40853
40854   jresult = result;
40855   return jresult;
40856 }
40857
40858
40859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40860   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40861   Dali::Radian arg2 ;
40862   Dali::Radian arg3 ;
40863   Dali::Radian *argp2 ;
40864   Dali::Radian *argp3 ;
40865
40866   arg1 = (Dali::PanGestureDetector *)jarg1;
40867   argp2 = (Dali::Radian *)jarg2;
40868   if (!argp2) {
40869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40870     return ;
40871   }
40872   arg2 = *argp2;
40873   argp3 = (Dali::Radian *)jarg3;
40874   if (!argp3) {
40875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40876     return ;
40877   }
40878   arg3 = *argp3;
40879   {
40880     try {
40881       (arg1)->AddAngle(arg2,arg3);
40882     } catch (std::out_of_range& e) {
40883       {
40884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40885       };
40886     } catch (std::exception& e) {
40887       {
40888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40889       };
40890     } catch (Dali::DaliException e) {
40891       {
40892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40893       };
40894     } catch (...) {
40895       {
40896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40897       };
40898     }
40899   }
40900
40901 }
40902
40903
40904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40905   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40906   Dali::Radian arg2 ;
40907   Dali::Radian *argp2 ;
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   {
40917     try {
40918       (arg1)->AddAngle(arg2);
40919     } catch (std::out_of_range& e) {
40920       {
40921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40922       };
40923     } catch (std::exception& e) {
40924       {
40925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40926       };
40927     } catch (Dali::DaliException e) {
40928       {
40929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40930       };
40931     } catch (...) {
40932       {
40933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40934       };
40935     }
40936   }
40937
40938 }
40939
40940
40941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40942   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40943   Dali::Radian arg2 ;
40944   Dali::Radian arg3 ;
40945   Dali::Radian *argp2 ;
40946   Dali::Radian *argp3 ;
40947
40948   arg1 = (Dali::PanGestureDetector *)jarg1;
40949   argp2 = (Dali::Radian *)jarg2;
40950   if (!argp2) {
40951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40952     return ;
40953   }
40954   arg2 = *argp2;
40955   argp3 = (Dali::Radian *)jarg3;
40956   if (!argp3) {
40957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40958     return ;
40959   }
40960   arg3 = *argp3;
40961   {
40962     try {
40963       (arg1)->AddDirection(arg2,arg3);
40964     } catch (std::out_of_range& e) {
40965       {
40966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40967       };
40968     } catch (std::exception& e) {
40969       {
40970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40971       };
40972     } catch (Dali::DaliException e) {
40973       {
40974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40975       };
40976     } catch (...) {
40977       {
40978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40979       };
40980     }
40981   }
40982
40983 }
40984
40985
40986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40987   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40988   Dali::Radian arg2 ;
40989   Dali::Radian *argp2 ;
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   {
40999     try {
41000       (arg1)->AddDirection(arg2);
41001     } catch (std::out_of_range& e) {
41002       {
41003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41004       };
41005     } catch (std::exception& e) {
41006       {
41007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41008       };
41009     } catch (Dali::DaliException e) {
41010       {
41011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41012       };
41013     } catch (...) {
41014       {
41015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41016       };
41017     }
41018   }
41019
41020 }
41021
41022
41023 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41024   unsigned long jresult ;
41025   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41026   size_t result;
41027
41028   arg1 = (Dali::PanGestureDetector *)jarg1;
41029   {
41030     try {
41031       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41032     } catch (std::out_of_range& e) {
41033       {
41034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41035       };
41036     } catch (std::exception& e) {
41037       {
41038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41039       };
41040     } catch (Dali::DaliException e) {
41041       {
41042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41043       };
41044     } catch (...) {
41045       {
41046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41047       };
41048     }
41049   }
41050
41051   jresult = (unsigned long)result;
41052   return jresult;
41053 }
41054
41055
41056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41057   void * jresult ;
41058   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41059   size_t arg2 ;
41060   Dali::PanGestureDetector::AngleThresholdPair result;
41061
41062   arg1 = (Dali::PanGestureDetector *)jarg1;
41063   arg2 = (size_t)jarg2;
41064   {
41065     try {
41066       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41067     } catch (std::out_of_range& e) {
41068       {
41069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41070       };
41071     } catch (std::exception& e) {
41072       {
41073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41074       };
41075     } catch (Dali::DaliException e) {
41076       {
41077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41078       };
41079     } catch (...) {
41080       {
41081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41082       };
41083     }
41084   }
41085
41086   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41087   return jresult;
41088 }
41089
41090
41091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41092   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41093
41094   arg1 = (Dali::PanGestureDetector *)jarg1;
41095   {
41096     try {
41097       (arg1)->ClearAngles();
41098     } catch (std::out_of_range& e) {
41099       {
41100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41101       };
41102     } catch (std::exception& e) {
41103       {
41104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41105       };
41106     } catch (Dali::DaliException e) {
41107       {
41108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41109       };
41110     } catch (...) {
41111       {
41112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41113       };
41114     }
41115   }
41116
41117 }
41118
41119
41120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41121   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41122   Dali::Radian arg2 ;
41123   Dali::Radian *argp2 ;
41124
41125   arg1 = (Dali::PanGestureDetector *)jarg1;
41126   argp2 = (Dali::Radian *)jarg2;
41127   if (!argp2) {
41128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41129     return ;
41130   }
41131   arg2 = *argp2;
41132   {
41133     try {
41134       (arg1)->RemoveAngle(arg2);
41135     } catch (std::out_of_range& e) {
41136       {
41137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41138       };
41139     } catch (std::exception& e) {
41140       {
41141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41142       };
41143     } catch (Dali::DaliException e) {
41144       {
41145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41146       };
41147     } catch (...) {
41148       {
41149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41150       };
41151     }
41152   }
41153
41154 }
41155
41156
41157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41158   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41159   Dali::Radian arg2 ;
41160   Dali::Radian *argp2 ;
41161
41162   arg1 = (Dali::PanGestureDetector *)jarg1;
41163   argp2 = (Dali::Radian *)jarg2;
41164   if (!argp2) {
41165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41166     return ;
41167   }
41168   arg2 = *argp2;
41169   {
41170     try {
41171       (arg1)->RemoveDirection(arg2);
41172     } catch (std::out_of_range& e) {
41173       {
41174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41175       };
41176     } catch (std::exception& e) {
41177       {
41178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41179       };
41180     } catch (Dali::DaliException e) {
41181       {
41182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41183       };
41184     } catch (...) {
41185       {
41186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41187       };
41188     }
41189   }
41190
41191 }
41192
41193
41194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41195   void * jresult ;
41196   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41197   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41198
41199   arg1 = (Dali::PanGestureDetector *)jarg1;
41200   {
41201     try {
41202       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41203     } catch (std::out_of_range& e) {
41204       {
41205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41206       };
41207     } catch (std::exception& e) {
41208       {
41209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41210       };
41211     } catch (Dali::DaliException e) {
41212       {
41213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41214       };
41215     } catch (...) {
41216       {
41217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41218       };
41219     }
41220   }
41221
41222   jresult = (void *)result;
41223   return jresult;
41224 }
41225
41226
41227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41228   Dali::PanGesture *arg1 = 0 ;
41229
41230   arg1 = (Dali::PanGesture *)jarg1;
41231   if (!arg1) {
41232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41233     return ;
41234   }
41235   {
41236     try {
41237       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41238     } catch (std::out_of_range& e) {
41239       {
41240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41241       };
41242     } catch (std::exception& e) {
41243       {
41244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41245       };
41246     } catch (Dali::DaliException e) {
41247       {
41248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41249       };
41250     } catch (...) {
41251       {
41252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41253       };
41254     }
41255   }
41256
41257 }
41258
41259
41260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41261   void * jresult ;
41262   Dali::PanGesture *result = 0 ;
41263
41264   {
41265     try {
41266       result = (Dali::PanGesture *)new Dali::PanGesture();
41267     } catch (std::out_of_range& e) {
41268       {
41269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41270       };
41271     } catch (std::exception& e) {
41272       {
41273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41274       };
41275     } catch (Dali::DaliException e) {
41276       {
41277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41278       };
41279     } catch (...) {
41280       {
41281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41282       };
41283     }
41284   }
41285
41286   jresult = (void *)result;
41287   return jresult;
41288 }
41289
41290
41291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41292   void * jresult ;
41293   Dali::Gesture::State arg1 ;
41294   Dali::PanGesture *result = 0 ;
41295
41296   arg1 = (Dali::Gesture::State)jarg1;
41297   {
41298     try {
41299       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41300     } catch (std::out_of_range& e) {
41301       {
41302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41303       };
41304     } catch (std::exception& e) {
41305       {
41306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41307       };
41308     } catch (Dali::DaliException e) {
41309       {
41310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41311       };
41312     } catch (...) {
41313       {
41314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41315       };
41316     }
41317   }
41318
41319   jresult = (void *)result;
41320   return jresult;
41321 }
41322
41323
41324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41325   void * jresult ;
41326   Dali::PanGesture *arg1 = 0 ;
41327   Dali::PanGesture *result = 0 ;
41328
41329   arg1 = (Dali::PanGesture *)jarg1;
41330   if (!arg1) {
41331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41332     return 0;
41333   }
41334   {
41335     try {
41336       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41337     } catch (std::out_of_range& e) {
41338       {
41339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41340       };
41341     } catch (std::exception& e) {
41342       {
41343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41344       };
41345     } catch (Dali::DaliException e) {
41346       {
41347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41348       };
41349     } catch (...) {
41350       {
41351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41352       };
41353     }
41354   }
41355
41356   jresult = (void *)result;
41357   return jresult;
41358 }
41359
41360
41361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41362   void * jresult ;
41363   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41364   Dali::PanGesture *arg2 = 0 ;
41365   Dali::PanGesture *result = 0 ;
41366
41367   arg1 = (Dali::PanGesture *)jarg1;
41368   arg2 = (Dali::PanGesture *)jarg2;
41369   if (!arg2) {
41370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41371     return 0;
41372   }
41373   {
41374     try {
41375       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41376     } catch (std::out_of_range& e) {
41377       {
41378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41379       };
41380     } catch (std::exception& e) {
41381       {
41382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41383       };
41384     } catch (Dali::DaliException e) {
41385       {
41386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41387       };
41388     } catch (...) {
41389       {
41390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41391       };
41392     }
41393   }
41394
41395   jresult = (void *)result;
41396   return jresult;
41397 }
41398
41399
41400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41401   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41402
41403   arg1 = (Dali::PanGesture *)jarg1;
41404   {
41405     try {
41406       delete arg1;
41407     } catch (std::out_of_range& e) {
41408       {
41409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41410       };
41411     } catch (std::exception& e) {
41412       {
41413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41414       };
41415     } catch (Dali::DaliException e) {
41416       {
41417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41418       };
41419     } catch (...) {
41420       {
41421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41422       };
41423     }
41424   }
41425
41426 }
41427
41428
41429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41430   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41431   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41432
41433   arg1 = (Dali::PanGesture *)jarg1;
41434   arg2 = (Dali::Vector2 *)jarg2;
41435   if (arg1) (arg1)->velocity = *arg2;
41436 }
41437
41438
41439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41440   void * jresult ;
41441   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41442   Dali::Vector2 *result = 0 ;
41443
41444   arg1 = (Dali::PanGesture *)jarg1;
41445   result = (Dali::Vector2 *)& ((arg1)->velocity);
41446   jresult = (void *)result;
41447   return jresult;
41448 }
41449
41450
41451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41452   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41453   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41454
41455   arg1 = (Dali::PanGesture *)jarg1;
41456   arg2 = (Dali::Vector2 *)jarg2;
41457   if (arg1) (arg1)->displacement = *arg2;
41458 }
41459
41460
41461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41462   void * jresult ;
41463   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41464   Dali::Vector2 *result = 0 ;
41465
41466   arg1 = (Dali::PanGesture *)jarg1;
41467   result = (Dali::Vector2 *)& ((arg1)->displacement);
41468   jresult = (void *)result;
41469   return jresult;
41470 }
41471
41472
41473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41474   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41475   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41476
41477   arg1 = (Dali::PanGesture *)jarg1;
41478   arg2 = (Dali::Vector2 *)jarg2;
41479   if (arg1) (arg1)->position = *arg2;
41480 }
41481
41482
41483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41484   void * jresult ;
41485   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41486   Dali::Vector2 *result = 0 ;
41487
41488   arg1 = (Dali::PanGesture *)jarg1;
41489   result = (Dali::Vector2 *)& ((arg1)->position);
41490   jresult = (void *)result;
41491   return jresult;
41492 }
41493
41494
41495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41496   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41497   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41498
41499   arg1 = (Dali::PanGesture *)jarg1;
41500   arg2 = (Dali::Vector2 *)jarg2;
41501   if (arg1) (arg1)->screenVelocity = *arg2;
41502 }
41503
41504
41505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41506   void * jresult ;
41507   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41508   Dali::Vector2 *result = 0 ;
41509
41510   arg1 = (Dali::PanGesture *)jarg1;
41511   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41512   jresult = (void *)result;
41513   return jresult;
41514 }
41515
41516
41517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41518   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41519   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41520
41521   arg1 = (Dali::PanGesture *)jarg1;
41522   arg2 = (Dali::Vector2 *)jarg2;
41523   if (arg1) (arg1)->screenDisplacement = *arg2;
41524 }
41525
41526
41527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41528   void * jresult ;
41529   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41530   Dali::Vector2 *result = 0 ;
41531
41532   arg1 = (Dali::PanGesture *)jarg1;
41533   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41534   jresult = (void *)result;
41535   return jresult;
41536 }
41537
41538
41539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41540   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41541   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41542
41543   arg1 = (Dali::PanGesture *)jarg1;
41544   arg2 = (Dali::Vector2 *)jarg2;
41545   if (arg1) (arg1)->screenPosition = *arg2;
41546 }
41547
41548
41549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41550   void * jresult ;
41551   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41552   Dali::Vector2 *result = 0 ;
41553
41554   arg1 = (Dali::PanGesture *)jarg1;
41555   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41556   jresult = (void *)result;
41557   return jresult;
41558 }
41559
41560
41561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41562   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41563   unsigned int arg2 ;
41564
41565   arg1 = (Dali::PanGesture *)jarg1;
41566   arg2 = (unsigned int)jarg2;
41567   if (arg1) (arg1)->numberOfTouches = arg2;
41568 }
41569
41570
41571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41572   unsigned int jresult ;
41573   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41574   unsigned int result;
41575
41576   arg1 = (Dali::PanGesture *)jarg1;
41577   result = (unsigned int) ((arg1)->numberOfTouches);
41578   jresult = result;
41579   return jresult;
41580 }
41581
41582
41583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41584   float jresult ;
41585   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41586   float result;
41587
41588   arg1 = (Dali::PanGesture *)jarg1;
41589   {
41590     try {
41591       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41592     } catch (std::out_of_range& e) {
41593       {
41594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41595       };
41596     } catch (std::exception& e) {
41597       {
41598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41599       };
41600     } catch (Dali::DaliException e) {
41601       {
41602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41603       };
41604     } catch (...) {
41605       {
41606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41607       };
41608     }
41609   }
41610
41611   jresult = result;
41612   return jresult;
41613 }
41614
41615
41616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41617   float jresult ;
41618   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41619   float result;
41620
41621   arg1 = (Dali::PanGesture *)jarg1;
41622   {
41623     try {
41624       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41625     } catch (std::out_of_range& e) {
41626       {
41627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41628       };
41629     } catch (std::exception& e) {
41630       {
41631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41632       };
41633     } catch (Dali::DaliException e) {
41634       {
41635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41636       };
41637     } catch (...) {
41638       {
41639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41640       };
41641     }
41642   }
41643
41644   jresult = result;
41645   return jresult;
41646 }
41647
41648
41649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41650   float jresult ;
41651   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41652   float result;
41653
41654   arg1 = (Dali::PanGesture *)jarg1;
41655   {
41656     try {
41657       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41658     } catch (std::out_of_range& e) {
41659       {
41660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41661       };
41662     } catch (std::exception& e) {
41663       {
41664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41665       };
41666     } catch (Dali::DaliException e) {
41667       {
41668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41669       };
41670     } catch (...) {
41671       {
41672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41673       };
41674     }
41675   }
41676
41677   jresult = result;
41678   return jresult;
41679 }
41680
41681
41682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41683   float jresult ;
41684   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41685   float result;
41686
41687   arg1 = (Dali::PanGesture *)jarg1;
41688   {
41689     try {
41690       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41691     } catch (std::out_of_range& e) {
41692       {
41693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41694       };
41695     } catch (std::exception& e) {
41696       {
41697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41698       };
41699     } catch (Dali::DaliException e) {
41700       {
41701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41702       };
41703     } catch (...) {
41704       {
41705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41706       };
41707     }
41708   }
41709
41710   jresult = result;
41711   return jresult;
41712 }
41713
41714
41715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41716   void * jresult ;
41717   Dali::PinchGestureDetector *result = 0 ;
41718
41719   {
41720     try {
41721       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41722     } catch (std::out_of_range& e) {
41723       {
41724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41725       };
41726     } catch (std::exception& e) {
41727       {
41728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41729       };
41730     } catch (Dali::DaliException e) {
41731       {
41732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41733       };
41734     } catch (...) {
41735       {
41736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41737       };
41738     }
41739   }
41740
41741   jresult = (void *)result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41747   void * jresult ;
41748   Dali::PinchGestureDetector result;
41749
41750   {
41751     try {
41752       result = Dali::PinchGestureDetector::New();
41753     } catch (std::out_of_range& e) {
41754       {
41755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41756       };
41757     } catch (std::exception& e) {
41758       {
41759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41760       };
41761     } catch (Dali::DaliException e) {
41762       {
41763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41764       };
41765     } catch (...) {
41766       {
41767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41768       };
41769     }
41770   }
41771
41772   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41773   return jresult;
41774 }
41775
41776
41777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41778   void * jresult ;
41779   Dali::BaseHandle arg1 ;
41780   Dali::BaseHandle *argp1 ;
41781   Dali::PinchGestureDetector result;
41782
41783   argp1 = (Dali::BaseHandle *)jarg1;
41784   if (!argp1) {
41785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41786     return 0;
41787   }
41788   arg1 = *argp1;
41789   {
41790     try {
41791       result = Dali::PinchGestureDetector::DownCast(arg1);
41792     } catch (std::out_of_range& e) {
41793       {
41794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (std::exception& e) {
41797       {
41798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41799       };
41800     } catch (Dali::DaliException e) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41803       };
41804     } catch (...) {
41805       {
41806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41807       };
41808     }
41809   }
41810
41811   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41812   return jresult;
41813 }
41814
41815
41816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41817   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41818
41819   arg1 = (Dali::PinchGestureDetector *)jarg1;
41820   {
41821     try {
41822       delete arg1;
41823     } catch (std::out_of_range& e) {
41824       {
41825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41826       };
41827     } catch (std::exception& e) {
41828       {
41829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41830       };
41831     } catch (Dali::DaliException e) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41834       };
41835     } catch (...) {
41836       {
41837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41838       };
41839     }
41840   }
41841
41842 }
41843
41844
41845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41846   void * jresult ;
41847   Dali::PinchGestureDetector *arg1 = 0 ;
41848   Dali::PinchGestureDetector *result = 0 ;
41849
41850   arg1 = (Dali::PinchGestureDetector *)jarg1;
41851   if (!arg1) {
41852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41853     return 0;
41854   }
41855   {
41856     try {
41857       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41858     } catch (std::out_of_range& e) {
41859       {
41860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41861       };
41862     } catch (std::exception& e) {
41863       {
41864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41865       };
41866     } catch (Dali::DaliException e) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41869       };
41870     } catch (...) {
41871       {
41872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41873       };
41874     }
41875   }
41876
41877   jresult = (void *)result;
41878   return jresult;
41879 }
41880
41881
41882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41883   void * jresult ;
41884   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41885   Dali::PinchGestureDetector *arg2 = 0 ;
41886   Dali::PinchGestureDetector *result = 0 ;
41887
41888   arg1 = (Dali::PinchGestureDetector *)jarg1;
41889   arg2 = (Dali::PinchGestureDetector *)jarg2;
41890   if (!arg2) {
41891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41892     return 0;
41893   }
41894   {
41895     try {
41896       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41897     } catch (std::out_of_range& e) {
41898       {
41899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41900       };
41901     } catch (std::exception& e) {
41902       {
41903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41904       };
41905     } catch (Dali::DaliException e) {
41906       {
41907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41908       };
41909     } catch (...) {
41910       {
41911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41912       };
41913     }
41914   }
41915
41916   jresult = (void *)result;
41917   return jresult;
41918 }
41919
41920
41921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41922   void * jresult ;
41923   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41924   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41925
41926   arg1 = (Dali::PinchGestureDetector *)jarg1;
41927   {
41928     try {
41929       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41930     } catch (std::out_of_range& e) {
41931       {
41932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41933       };
41934     } catch (std::exception& e) {
41935       {
41936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41937       };
41938     } catch (Dali::DaliException e) {
41939       {
41940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41941       };
41942     } catch (...) {
41943       {
41944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41945       };
41946     }
41947   }
41948
41949   jresult = (void *)result;
41950   return jresult;
41951 }
41952
41953
41954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41955   void * jresult ;
41956   Dali::Gesture::State arg1 ;
41957   Dali::PinchGesture *result = 0 ;
41958
41959   arg1 = (Dali::Gesture::State)jarg1;
41960   {
41961     try {
41962       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41963     } catch (std::out_of_range& e) {
41964       {
41965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41966       };
41967     } catch (std::exception& e) {
41968       {
41969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41970       };
41971     } catch (Dali::DaliException e) {
41972       {
41973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41974       };
41975     } catch (...) {
41976       {
41977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41978       };
41979     }
41980   }
41981
41982   jresult = (void *)result;
41983   return jresult;
41984 }
41985
41986
41987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41988   void * jresult ;
41989   Dali::PinchGesture *arg1 = 0 ;
41990   Dali::PinchGesture *result = 0 ;
41991
41992   arg1 = (Dali::PinchGesture *)jarg1;
41993   if (!arg1) {
41994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41995     return 0;
41996   }
41997   {
41998     try {
41999       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42000     } catch (std::out_of_range& e) {
42001       {
42002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42003       };
42004     } catch (std::exception& e) {
42005       {
42006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42007       };
42008     } catch (Dali::DaliException e) {
42009       {
42010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42011       };
42012     } catch (...) {
42013       {
42014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42015       };
42016     }
42017   }
42018
42019   jresult = (void *)result;
42020   return jresult;
42021 }
42022
42023
42024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42025   void * jresult ;
42026   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42027   Dali::PinchGesture *arg2 = 0 ;
42028   Dali::PinchGesture *result = 0 ;
42029
42030   arg1 = (Dali::PinchGesture *)jarg1;
42031   arg2 = (Dali::PinchGesture *)jarg2;
42032   if (!arg2) {
42033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42034     return 0;
42035   }
42036   {
42037     try {
42038       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42039     } catch (std::out_of_range& e) {
42040       {
42041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42042       };
42043     } catch (std::exception& e) {
42044       {
42045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42046       };
42047     } catch (Dali::DaliException e) {
42048       {
42049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42050       };
42051     } catch (...) {
42052       {
42053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42054       };
42055     }
42056   }
42057
42058   jresult = (void *)result;
42059   return jresult;
42060 }
42061
42062
42063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42064   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42065
42066   arg1 = (Dali::PinchGesture *)jarg1;
42067   {
42068     try {
42069       delete arg1;
42070     } catch (std::out_of_range& e) {
42071       {
42072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42073       };
42074     } catch (std::exception& e) {
42075       {
42076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42077       };
42078     } catch (Dali::DaliException e) {
42079       {
42080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42081       };
42082     } catch (...) {
42083       {
42084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42085       };
42086     }
42087   }
42088
42089 }
42090
42091
42092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42093   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42094   float arg2 ;
42095
42096   arg1 = (Dali::PinchGesture *)jarg1;
42097   arg2 = (float)jarg2;
42098   if (arg1) (arg1)->scale = arg2;
42099 }
42100
42101
42102 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42103   float jresult ;
42104   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42105   float result;
42106
42107   arg1 = (Dali::PinchGesture *)jarg1;
42108   result = (float) ((arg1)->scale);
42109   jresult = result;
42110   return jresult;
42111 }
42112
42113
42114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42115   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42116   float arg2 ;
42117
42118   arg1 = (Dali::PinchGesture *)jarg1;
42119   arg2 = (float)jarg2;
42120   if (arg1) (arg1)->speed = arg2;
42121 }
42122
42123
42124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42125   float jresult ;
42126   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42127   float result;
42128
42129   arg1 = (Dali::PinchGesture *)jarg1;
42130   result = (float) ((arg1)->speed);
42131   jresult = result;
42132   return jresult;
42133 }
42134
42135
42136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42137   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42138   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42139
42140   arg1 = (Dali::PinchGesture *)jarg1;
42141   arg2 = (Dali::Vector2 *)jarg2;
42142   if (arg1) (arg1)->screenCenterPoint = *arg2;
42143 }
42144
42145
42146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42147   void * jresult ;
42148   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42149   Dali::Vector2 *result = 0 ;
42150
42151   arg1 = (Dali::PinchGesture *)jarg1;
42152   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42153   jresult = (void *)result;
42154   return jresult;
42155 }
42156
42157
42158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42159   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42160   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42161
42162   arg1 = (Dali::PinchGesture *)jarg1;
42163   arg2 = (Dali::Vector2 *)jarg2;
42164   if (arg1) (arg1)->localCenterPoint = *arg2;
42165 }
42166
42167
42168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42169   void * jresult ;
42170   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42171   Dali::Vector2 *result = 0 ;
42172
42173   arg1 = (Dali::PinchGesture *)jarg1;
42174   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42175   jresult = (void *)result;
42176   return jresult;
42177 }
42178
42179
42180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42181   void * jresult ;
42182   Dali::TapGestureDetector *result = 0 ;
42183
42184   {
42185     try {
42186       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42187     } catch (std::out_of_range& e) {
42188       {
42189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42190       };
42191     } catch (std::exception& e) {
42192       {
42193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42194       };
42195     } catch (Dali::DaliException e) {
42196       {
42197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42198       };
42199     } catch (...) {
42200       {
42201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42202       };
42203     }
42204   }
42205
42206   jresult = (void *)result;
42207   return jresult;
42208 }
42209
42210
42211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42212   void * jresult ;
42213   Dali::TapGestureDetector result;
42214
42215   {
42216     try {
42217       result = Dali::TapGestureDetector::New();
42218     } catch (std::out_of_range& e) {
42219       {
42220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42221       };
42222     } catch (std::exception& e) {
42223       {
42224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42225       };
42226     } catch (Dali::DaliException e) {
42227       {
42228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42229       };
42230     } catch (...) {
42231       {
42232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42233       };
42234     }
42235   }
42236
42237   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42238   return jresult;
42239 }
42240
42241
42242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42243   void * jresult ;
42244   unsigned int arg1 ;
42245   Dali::TapGestureDetector result;
42246
42247   arg1 = (unsigned int)jarg1;
42248   {
42249     try {
42250       result = Dali::TapGestureDetector::New(arg1);
42251     } catch (std::out_of_range& e) {
42252       {
42253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42254       };
42255     } catch (std::exception& e) {
42256       {
42257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42258       };
42259     } catch (Dali::DaliException e) {
42260       {
42261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42262       };
42263     } catch (...) {
42264       {
42265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42266       };
42267     }
42268   }
42269
42270   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42271   return jresult;
42272 }
42273
42274
42275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42276   void * jresult ;
42277   Dali::BaseHandle arg1 ;
42278   Dali::BaseHandle *argp1 ;
42279   Dali::TapGestureDetector result;
42280
42281   argp1 = (Dali::BaseHandle *)jarg1;
42282   if (!argp1) {
42283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42284     return 0;
42285   }
42286   arg1 = *argp1;
42287   {
42288     try {
42289       result = Dali::TapGestureDetector::DownCast(arg1);
42290     } catch (std::out_of_range& e) {
42291       {
42292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42293       };
42294     } catch (std::exception& e) {
42295       {
42296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42297       };
42298     } catch (Dali::DaliException e) {
42299       {
42300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42301       };
42302     } catch (...) {
42303       {
42304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42305       };
42306     }
42307   }
42308
42309   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42310   return jresult;
42311 }
42312
42313
42314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42315   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42316
42317   arg1 = (Dali::TapGestureDetector *)jarg1;
42318   {
42319     try {
42320       delete arg1;
42321     } catch (std::out_of_range& e) {
42322       {
42323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42324       };
42325     } catch (std::exception& e) {
42326       {
42327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42328       };
42329     } catch (Dali::DaliException e) {
42330       {
42331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42332       };
42333     } catch (...) {
42334       {
42335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42336       };
42337     }
42338   }
42339
42340 }
42341
42342
42343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42344   void * jresult ;
42345   Dali::TapGestureDetector *arg1 = 0 ;
42346   Dali::TapGestureDetector *result = 0 ;
42347
42348   arg1 = (Dali::TapGestureDetector *)jarg1;
42349   if (!arg1) {
42350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42351     return 0;
42352   }
42353   {
42354     try {
42355       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42356     } catch (std::out_of_range& e) {
42357       {
42358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42359       };
42360     } catch (std::exception& e) {
42361       {
42362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42363       };
42364     } catch (Dali::DaliException e) {
42365       {
42366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42367       };
42368     } catch (...) {
42369       {
42370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42371       };
42372     }
42373   }
42374
42375   jresult = (void *)result;
42376   return jresult;
42377 }
42378
42379
42380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42381   void * jresult ;
42382   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42383   Dali::TapGestureDetector *arg2 = 0 ;
42384   Dali::TapGestureDetector *result = 0 ;
42385
42386   arg1 = (Dali::TapGestureDetector *)jarg1;
42387   arg2 = (Dali::TapGestureDetector *)jarg2;
42388   if (!arg2) {
42389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42390     return 0;
42391   }
42392   {
42393     try {
42394       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42395     } catch (std::out_of_range& e) {
42396       {
42397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42398       };
42399     } catch (std::exception& e) {
42400       {
42401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42402       };
42403     } catch (Dali::DaliException e) {
42404       {
42405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42406       };
42407     } catch (...) {
42408       {
42409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42410       };
42411     }
42412   }
42413
42414   jresult = (void *)result;
42415   return jresult;
42416 }
42417
42418
42419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42420   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42421   unsigned int arg2 ;
42422
42423   arg1 = (Dali::TapGestureDetector *)jarg1;
42424   arg2 = (unsigned int)jarg2;
42425   {
42426     try {
42427       (arg1)->SetMinimumTapsRequired(arg2);
42428     } catch (std::out_of_range& e) {
42429       {
42430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42431       };
42432     } catch (std::exception& e) {
42433       {
42434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42435       };
42436     } catch (Dali::DaliException e) {
42437       {
42438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42439       };
42440     } catch (...) {
42441       {
42442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42443       };
42444     }
42445   }
42446
42447 }
42448
42449
42450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42451   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42452   unsigned int arg2 ;
42453
42454   arg1 = (Dali::TapGestureDetector *)jarg1;
42455   arg2 = (unsigned int)jarg2;
42456   {
42457     try {
42458       (arg1)->SetMaximumTapsRequired(arg2);
42459     } catch (std::out_of_range& e) {
42460       {
42461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42462       };
42463     } catch (std::exception& e) {
42464       {
42465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42466       };
42467     } catch (Dali::DaliException e) {
42468       {
42469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42470       };
42471     } catch (...) {
42472       {
42473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42474       };
42475     }
42476   }
42477
42478 }
42479
42480
42481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42482   unsigned int jresult ;
42483   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42484   unsigned int result;
42485
42486   arg1 = (Dali::TapGestureDetector *)jarg1;
42487   {
42488     try {
42489       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42490     } catch (std::out_of_range& e) {
42491       {
42492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42493       };
42494     } catch (std::exception& e) {
42495       {
42496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42497       };
42498     } catch (Dali::DaliException e) {
42499       {
42500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42501       };
42502     } catch (...) {
42503       {
42504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42505       };
42506     }
42507   }
42508
42509   jresult = result;
42510   return jresult;
42511 }
42512
42513
42514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42515   unsigned int jresult ;
42516   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42517   unsigned int result;
42518
42519   arg1 = (Dali::TapGestureDetector *)jarg1;
42520   {
42521     try {
42522       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42523     } catch (std::out_of_range& e) {
42524       {
42525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (std::exception& e) {
42528       {
42529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42530       };
42531     } catch (Dali::DaliException e) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42534       };
42535     } catch (...) {
42536       {
42537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42538       };
42539     }
42540   }
42541
42542   jresult = result;
42543   return jresult;
42544 }
42545
42546
42547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42548   void * jresult ;
42549   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42550   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42551
42552   arg1 = (Dali::TapGestureDetector *)jarg1;
42553   {
42554     try {
42555       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42556     } catch (std::out_of_range& e) {
42557       {
42558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42559       };
42560     } catch (std::exception& e) {
42561       {
42562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42563       };
42564     } catch (Dali::DaliException e) {
42565       {
42566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42567       };
42568     } catch (...) {
42569       {
42570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42571       };
42572     }
42573   }
42574
42575   jresult = (void *)result;
42576   return jresult;
42577 }
42578
42579
42580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42581   void * jresult ;
42582   Dali::TapGesture *result = 0 ;
42583
42584   {
42585     try {
42586       result = (Dali::TapGesture *)new Dali::TapGesture();
42587     } catch (std::out_of_range& e) {
42588       {
42589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42590       };
42591     } catch (std::exception& e) {
42592       {
42593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42594       };
42595     } catch (Dali::DaliException e) {
42596       {
42597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42598       };
42599     } catch (...) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42602       };
42603     }
42604   }
42605
42606   jresult = (void *)result;
42607   return jresult;
42608 }
42609
42610
42611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42612   void * jresult ;
42613   Dali::TapGesture *arg1 = 0 ;
42614   Dali::TapGesture *result = 0 ;
42615
42616   arg1 = (Dali::TapGesture *)jarg1;
42617   if (!arg1) {
42618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42619     return 0;
42620   }
42621   {
42622     try {
42623       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42624     } catch (std::out_of_range& e) {
42625       {
42626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42627       };
42628     } catch (std::exception& e) {
42629       {
42630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42631       };
42632     } catch (Dali::DaliException e) {
42633       {
42634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42635       };
42636     } catch (...) {
42637       {
42638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42639       };
42640     }
42641   }
42642
42643   jresult = (void *)result;
42644   return jresult;
42645 }
42646
42647
42648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42649   void * jresult ;
42650   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42651   Dali::TapGesture *arg2 = 0 ;
42652   Dali::TapGesture *result = 0 ;
42653
42654   arg1 = (Dali::TapGesture *)jarg1;
42655   arg2 = (Dali::TapGesture *)jarg2;
42656   if (!arg2) {
42657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42658     return 0;
42659   }
42660   {
42661     try {
42662       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42663     } catch (std::out_of_range& e) {
42664       {
42665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42666       };
42667     } catch (std::exception& e) {
42668       {
42669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42670       };
42671     } catch (Dali::DaliException e) {
42672       {
42673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42674       };
42675     } catch (...) {
42676       {
42677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42678       };
42679     }
42680   }
42681
42682   jresult = (void *)result;
42683   return jresult;
42684 }
42685
42686
42687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42688   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42689
42690   arg1 = (Dali::TapGesture *)jarg1;
42691   {
42692     try {
42693       delete arg1;
42694     } catch (std::out_of_range& e) {
42695       {
42696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42697       };
42698     } catch (std::exception& e) {
42699       {
42700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42701       };
42702     } catch (Dali::DaliException e) {
42703       {
42704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42705       };
42706     } catch (...) {
42707       {
42708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42709       };
42710     }
42711   }
42712
42713 }
42714
42715
42716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42717   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42718   unsigned int arg2 ;
42719
42720   arg1 = (Dali::TapGesture *)jarg1;
42721   arg2 = (unsigned int)jarg2;
42722   if (arg1) (arg1)->numberOfTaps = arg2;
42723 }
42724
42725
42726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42727   unsigned int jresult ;
42728   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42729   unsigned int result;
42730
42731   arg1 = (Dali::TapGesture *)jarg1;
42732   result = (unsigned int) ((arg1)->numberOfTaps);
42733   jresult = result;
42734   return jresult;
42735 }
42736
42737
42738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42739   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42740   unsigned int arg2 ;
42741
42742   arg1 = (Dali::TapGesture *)jarg1;
42743   arg2 = (unsigned int)jarg2;
42744   if (arg1) (arg1)->numberOfTouches = arg2;
42745 }
42746
42747
42748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42749   unsigned int jresult ;
42750   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42751   unsigned int result;
42752
42753   arg1 = (Dali::TapGesture *)jarg1;
42754   result = (unsigned int) ((arg1)->numberOfTouches);
42755   jresult = result;
42756   return jresult;
42757 }
42758
42759
42760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42761   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42762   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42763
42764   arg1 = (Dali::TapGesture *)jarg1;
42765   arg2 = (Dali::Vector2 *)jarg2;
42766   if (arg1) (arg1)->screenPoint = *arg2;
42767 }
42768
42769
42770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42771   void * jresult ;
42772   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42773   Dali::Vector2 *result = 0 ;
42774
42775   arg1 = (Dali::TapGesture *)jarg1;
42776   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42777   jresult = (void *)result;
42778   return jresult;
42779 }
42780
42781
42782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42783   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42784   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42785
42786   arg1 = (Dali::TapGesture *)jarg1;
42787   arg2 = (Dali::Vector2 *)jarg2;
42788   if (arg1) (arg1)->localPoint = *arg2;
42789 }
42790
42791
42792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42793   void * jresult ;
42794   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42795   Dali::Vector2 *result = 0 ;
42796
42797   arg1 = (Dali::TapGesture *)jarg1;
42798   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42799   jresult = (void *)result;
42800   return jresult;
42801 }
42802
42803
42804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42805   void * jresult ;
42806   Dali::AlphaFunction *result = 0 ;
42807
42808   {
42809     try {
42810       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42811     } catch (std::out_of_range& e) {
42812       {
42813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42814       };
42815     } catch (std::exception& e) {
42816       {
42817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42818       };
42819     } catch (Dali::DaliException e) {
42820       {
42821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42822       };
42823     } catch (...) {
42824       {
42825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42826       };
42827     }
42828   }
42829
42830   jresult = (void *)result;
42831   return jresult;
42832 }
42833
42834
42835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42836   void * jresult ;
42837   Dali::AlphaFunction::BuiltinFunction arg1 ;
42838   Dali::AlphaFunction *result = 0 ;
42839
42840   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42841   {
42842     try {
42843       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42844     } catch (std::out_of_range& e) {
42845       {
42846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42847       };
42848     } catch (std::exception& e) {
42849       {
42850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (Dali::DaliException e) {
42853       {
42854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42855       };
42856     } catch (...) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42859       };
42860     }
42861   }
42862
42863   jresult = (void *)result;
42864   return jresult;
42865 }
42866
42867
42868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42869   void * jresult ;
42870   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42871   Dali::AlphaFunction *result = 0 ;
42872
42873   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42874   {
42875     try {
42876       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42877     } catch (std::out_of_range& e) {
42878       {
42879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42880       };
42881     } catch (std::exception& e) {
42882       {
42883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42884       };
42885     } catch (Dali::DaliException e) {
42886       {
42887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42888       };
42889     } catch (...) {
42890       {
42891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42892       };
42893     }
42894   }
42895
42896   jresult = (void *)result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42902   void * jresult ;
42903   Dali::Vector2 *arg1 = 0 ;
42904   Dali::Vector2 *arg2 = 0 ;
42905   Dali::AlphaFunction *result = 0 ;
42906
42907   arg1 = (Dali::Vector2 *)jarg1;
42908   if (!arg1) {
42909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42910     return 0;
42911   }
42912   arg2 = (Dali::Vector2 *)jarg2;
42913   if (!arg2) {
42914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42915     return 0;
42916   }
42917   {
42918     try {
42919       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
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_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42945   void * jresult ;
42946   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42947   Dali::Vector4 result;
42948
42949   arg1 = (Dali::AlphaFunction *)jarg1;
42950   {
42951     try {
42952       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42953     } catch (std::out_of_range& e) {
42954       {
42955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42956       };
42957     } catch (std::exception& e) {
42958       {
42959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42960       };
42961     } catch (Dali::DaliException e) {
42962       {
42963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42964       };
42965     } catch (...) {
42966       {
42967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42968       };
42969     }
42970   }
42971
42972   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42973   return jresult;
42974 }
42975
42976
42977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42978   void * jresult ;
42979   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42980   Dali::AlphaFunctionPrototype result;
42981
42982   arg1 = (Dali::AlphaFunction *)jarg1;
42983   {
42984     try {
42985       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42986     } catch (std::out_of_range& e) {
42987       {
42988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42989       };
42990     } catch (std::exception& e) {
42991       {
42992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42993       };
42994     } catch (Dali::DaliException e) {
42995       {
42996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42997       };
42998     } catch (...) {
42999       {
43000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43001       };
43002     }
43003   }
43004
43005   jresult = (void *)result;
43006   return jresult;
43007 }
43008
43009
43010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43011   int jresult ;
43012   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43013   Dali::AlphaFunction::BuiltinFunction result;
43014
43015   arg1 = (Dali::AlphaFunction *)jarg1;
43016   {
43017     try {
43018       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43019     } catch (std::out_of_range& e) {
43020       {
43021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43022       };
43023     } catch (std::exception& e) {
43024       {
43025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43026       };
43027     } catch (Dali::DaliException e) {
43028       {
43029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43030       };
43031     } catch (...) {
43032       {
43033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43034       };
43035     }
43036   }
43037
43038   jresult = (int)result;
43039   return jresult;
43040 }
43041
43042
43043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43044   int jresult ;
43045   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43046   Dali::AlphaFunction::Mode result;
43047
43048   arg1 = (Dali::AlphaFunction *)jarg1;
43049   {
43050     try {
43051       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43052     } catch (std::out_of_range& e) {
43053       {
43054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43055       };
43056     } catch (std::exception& e) {
43057       {
43058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43059       };
43060     } catch (Dali::DaliException e) {
43061       {
43062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43063       };
43064     } catch (...) {
43065       {
43066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43067       };
43068     }
43069   }
43070
43071   jresult = (int)result;
43072   return jresult;
43073 }
43074
43075
43076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43077   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43078
43079   arg1 = (Dali::AlphaFunction *)jarg1;
43080   {
43081     try {
43082       delete arg1;
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43098       };
43099     }
43100   }
43101
43102 }
43103
43104
43105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43106   void * jresult ;
43107   Dali::KeyFrames result;
43108
43109   {
43110     try {
43111       result = Dali::KeyFrames::New();
43112     } catch (std::out_of_range& e) {
43113       {
43114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43115       };
43116     } catch (std::exception& e) {
43117       {
43118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (Dali::DaliException e) {
43121       {
43122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43123       };
43124     } catch (...) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43127       };
43128     }
43129   }
43130
43131   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43132   return jresult;
43133 }
43134
43135
43136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43137   void * jresult ;
43138   Dali::BaseHandle arg1 ;
43139   Dali::BaseHandle *argp1 ;
43140   Dali::KeyFrames result;
43141
43142   argp1 = (Dali::BaseHandle *)jarg1;
43143   if (!argp1) {
43144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43145     return 0;
43146   }
43147   arg1 = *argp1;
43148   {
43149     try {
43150       result = Dali::KeyFrames::DownCast(arg1);
43151     } catch (std::out_of_range& e) {
43152       {
43153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43154       };
43155     } catch (std::exception& e) {
43156       {
43157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43158       };
43159     } catch (Dali::DaliException e) {
43160       {
43161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43162       };
43163     } catch (...) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43166       };
43167     }
43168   }
43169
43170   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43171   return jresult;
43172 }
43173
43174
43175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43176   void * jresult ;
43177   Dali::KeyFrames *result = 0 ;
43178
43179   {
43180     try {
43181       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43182     } catch (std::out_of_range& e) {
43183       {
43184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (std::exception& e) {
43187       {
43188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43189       };
43190     } catch (Dali::DaliException e) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43193       };
43194     } catch (...) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43197       };
43198     }
43199   }
43200
43201   jresult = (void *)result;
43202   return jresult;
43203 }
43204
43205
43206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43207   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43208
43209   arg1 = (Dali::KeyFrames *)jarg1;
43210   {
43211     try {
43212       delete arg1;
43213     } catch (std::out_of_range& e) {
43214       {
43215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43216       };
43217     } catch (std::exception& e) {
43218       {
43219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43220       };
43221     } catch (Dali::DaliException e) {
43222       {
43223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43224       };
43225     } catch (...) {
43226       {
43227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43228       };
43229     }
43230   }
43231
43232 }
43233
43234
43235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43236   void * jresult ;
43237   Dali::KeyFrames *arg1 = 0 ;
43238   Dali::KeyFrames *result = 0 ;
43239
43240   arg1 = (Dali::KeyFrames *)jarg1;
43241   if (!arg1) {
43242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43243     return 0;
43244   }
43245   {
43246     try {
43247       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43248     } catch (std::out_of_range& e) {
43249       {
43250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43251       };
43252     } catch (std::exception& e) {
43253       {
43254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43255       };
43256     } catch (Dali::DaliException e) {
43257       {
43258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43259       };
43260     } catch (...) {
43261       {
43262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43263       };
43264     }
43265   }
43266
43267   jresult = (void *)result;
43268   return jresult;
43269 }
43270
43271
43272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43273   void * jresult ;
43274   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43275   Dali::KeyFrames *arg2 = 0 ;
43276   Dali::KeyFrames *result = 0 ;
43277
43278   arg1 = (Dali::KeyFrames *)jarg1;
43279   arg2 = (Dali::KeyFrames *)jarg2;
43280   if (!arg2) {
43281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43282     return 0;
43283   }
43284   {
43285     try {
43286       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43287     } catch (std::out_of_range& e) {
43288       {
43289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43290       };
43291     } catch (std::exception& e) {
43292       {
43293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43294       };
43295     } catch (Dali::DaliException e) {
43296       {
43297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43298       };
43299     } catch (...) {
43300       {
43301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43302       };
43303     }
43304   }
43305
43306   jresult = (void *)result;
43307   return jresult;
43308 }
43309
43310
43311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43312   int jresult ;
43313   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43314   Dali::Property::Type result;
43315
43316   arg1 = (Dali::KeyFrames *)jarg1;
43317   {
43318     try {
43319       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43320     } catch (std::out_of_range& e) {
43321       {
43322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43323       };
43324     } catch (std::exception& e) {
43325       {
43326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43327       };
43328     } catch (Dali::DaliException e) {
43329       {
43330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43331       };
43332     } catch (...) {
43333       {
43334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43335       };
43336     }
43337   }
43338
43339   jresult = (int)result;
43340   return jresult;
43341 }
43342
43343
43344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43345   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43346   float arg2 ;
43347   Dali::Property::Value arg3 ;
43348   Dali::Property::Value *argp3 ;
43349
43350   arg1 = (Dali::KeyFrames *)jarg1;
43351   arg2 = (float)jarg2;
43352   argp3 = (Dali::Property::Value *)jarg3;
43353   if (!argp3) {
43354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43355     return ;
43356   }
43357   arg3 = *argp3;
43358   {
43359     try {
43360       (arg1)->Add(arg2,arg3);
43361     } catch (std::out_of_range& e) {
43362       {
43363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43364       };
43365     } catch (std::exception& e) {
43366       {
43367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43368       };
43369     } catch (Dali::DaliException e) {
43370       {
43371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43372       };
43373     } catch (...) {
43374       {
43375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43376       };
43377     }
43378   }
43379
43380 }
43381
43382
43383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43384   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43385   float arg2 ;
43386   Dali::Property::Value arg3 ;
43387   Dali::AlphaFunction arg4 ;
43388   Dali::Property::Value *argp3 ;
43389   Dali::AlphaFunction *argp4 ;
43390
43391   arg1 = (Dali::KeyFrames *)jarg1;
43392   arg2 = (float)jarg2;
43393   argp3 = (Dali::Property::Value *)jarg3;
43394   if (!argp3) {
43395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43396     return ;
43397   }
43398   arg3 = *argp3;
43399   argp4 = (Dali::AlphaFunction *)jarg4;
43400   if (!argp4) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43402     return ;
43403   }
43404   arg4 = *argp4;
43405   {
43406     try {
43407       (arg1)->Add(arg2,arg3,arg4);
43408     } catch (std::out_of_range& e) {
43409       {
43410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43411       };
43412     } catch (std::exception& e) {
43413       {
43414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43415       };
43416     } catch (Dali::DaliException e) {
43417       {
43418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43419       };
43420     } catch (...) {
43421       {
43422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43423       };
43424     }
43425   }
43426
43427 }
43428
43429
43430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43431   int jresult ;
43432   int result;
43433
43434   result = (int)Dali::Path::Property::POINTS;
43435   jresult = (int)result;
43436   return jresult;
43437 }
43438
43439
43440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43441   int jresult ;
43442   int result;
43443
43444   result = (int)Dali::Path::Property::CONTROL_POINTS;
43445   jresult = (int)result;
43446   return jresult;
43447 }
43448
43449
43450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43451   void * jresult ;
43452   Dali::Path::Property *result = 0 ;
43453
43454   {
43455     try {
43456       result = (Dali::Path::Property *)new Dali::Path::Property();
43457     } catch (std::out_of_range& e) {
43458       {
43459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43460       };
43461     } catch (std::exception& e) {
43462       {
43463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43464       };
43465     } catch (Dali::DaliException e) {
43466       {
43467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43468       };
43469     } catch (...) {
43470       {
43471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43472       };
43473     }
43474   }
43475
43476   jresult = (void *)result;
43477   return jresult;
43478 }
43479
43480
43481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43482   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43483
43484   arg1 = (Dali::Path::Property *)jarg1;
43485   {
43486     try {
43487       delete arg1;
43488     } catch (std::out_of_range& e) {
43489       {
43490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43491       };
43492     } catch (std::exception& e) {
43493       {
43494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43495       };
43496     } catch (Dali::DaliException e) {
43497       {
43498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43499       };
43500     } catch (...) {
43501       {
43502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43503       };
43504     }
43505   }
43506
43507 }
43508
43509
43510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43511   void * jresult ;
43512   Dali::Path result;
43513
43514   {
43515     try {
43516       result = Dali::Path::New();
43517     } catch (std::out_of_range& e) {
43518       {
43519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43520       };
43521     } catch (std::exception& e) {
43522       {
43523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (Dali::DaliException e) {
43526       {
43527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43528       };
43529     } catch (...) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43532       };
43533     }
43534   }
43535
43536   jresult = new Dali::Path((const Dali::Path &)result);
43537   return jresult;
43538 }
43539
43540
43541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43542   void * jresult ;
43543   Dali::BaseHandle arg1 ;
43544   Dali::BaseHandle *argp1 ;
43545   Dali::Path result;
43546
43547   argp1 = (Dali::BaseHandle *)jarg1;
43548   if (!argp1) {
43549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43550     return 0;
43551   }
43552   arg1 = *argp1;
43553   {
43554     try {
43555       result = Dali::Path::DownCast(arg1);
43556     } catch (std::out_of_range& e) {
43557       {
43558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43559       };
43560     } catch (std::exception& e) {
43561       {
43562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43563       };
43564     } catch (Dali::DaliException e) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43567       };
43568     } catch (...) {
43569       {
43570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43571       };
43572     }
43573   }
43574
43575   jresult = new Dali::Path((const Dali::Path &)result);
43576   return jresult;
43577 }
43578
43579
43580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43581   void * jresult ;
43582   Dali::Path *result = 0 ;
43583
43584   {
43585     try {
43586       result = (Dali::Path *)new Dali::Path();
43587     } catch (std::out_of_range& e) {
43588       {
43589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43590       };
43591     } catch (std::exception& e) {
43592       {
43593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43594       };
43595     } catch (Dali::DaliException e) {
43596       {
43597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43598       };
43599     } catch (...) {
43600       {
43601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43602       };
43603     }
43604   }
43605
43606   jresult = (void *)result;
43607   return jresult;
43608 }
43609
43610
43611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43612   Dali::Path *arg1 = (Dali::Path *) 0 ;
43613
43614   arg1 = (Dali::Path *)jarg1;
43615   {
43616     try {
43617       delete arg1;
43618     } catch (std::out_of_range& e) {
43619       {
43620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43621       };
43622     } catch (std::exception& e) {
43623       {
43624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43625       };
43626     } catch (Dali::DaliException e) {
43627       {
43628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43629       };
43630     } catch (...) {
43631       {
43632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43633       };
43634     }
43635   }
43636
43637 }
43638
43639
43640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43641   void * jresult ;
43642   Dali::Path *arg1 = 0 ;
43643   Dali::Path *result = 0 ;
43644
43645   arg1 = (Dali::Path *)jarg1;
43646   if (!arg1) {
43647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43648     return 0;
43649   }
43650   {
43651     try {
43652       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43653     } catch (std::out_of_range& e) {
43654       {
43655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43656       };
43657     } catch (std::exception& e) {
43658       {
43659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43660       };
43661     } catch (Dali::DaliException e) {
43662       {
43663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43664       };
43665     } catch (...) {
43666       {
43667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43668       };
43669     }
43670   }
43671
43672   jresult = (void *)result;
43673   return jresult;
43674 }
43675
43676
43677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43678   void * jresult ;
43679   Dali::Path *arg1 = (Dali::Path *) 0 ;
43680   Dali::Path *arg2 = 0 ;
43681   Dali::Path *result = 0 ;
43682
43683   arg1 = (Dali::Path *)jarg1;
43684   arg2 = (Dali::Path *)jarg2;
43685   if (!arg2) {
43686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43687     return 0;
43688   }
43689   {
43690     try {
43691       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43692     } catch (std::out_of_range& e) {
43693       {
43694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43695       };
43696     } catch (std::exception& e) {
43697       {
43698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43699       };
43700     } catch (Dali::DaliException e) {
43701       {
43702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43703       };
43704     } catch (...) {
43705       {
43706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43707       };
43708     }
43709   }
43710
43711   jresult = (void *)result;
43712   return jresult;
43713 }
43714
43715
43716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43717   Dali::Path *arg1 = (Dali::Path *) 0 ;
43718   Dali::Vector3 *arg2 = 0 ;
43719
43720   arg1 = (Dali::Path *)jarg1;
43721   arg2 = (Dali::Vector3 *)jarg2;
43722   if (!arg2) {
43723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43724     return ;
43725   }
43726   {
43727     try {
43728       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (Dali::DaliException e) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43744       };
43745     }
43746   }
43747
43748 }
43749
43750
43751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43752   Dali::Path *arg1 = (Dali::Path *) 0 ;
43753   Dali::Vector3 *arg2 = 0 ;
43754
43755   arg1 = (Dali::Path *)jarg1;
43756   arg2 = (Dali::Vector3 *)jarg2;
43757   if (!arg2) {
43758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43759     return ;
43760   }
43761   {
43762     try {
43763       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43764     } catch (std::out_of_range& e) {
43765       {
43766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43767       };
43768     } catch (std::exception& e) {
43769       {
43770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43771       };
43772     } catch (Dali::DaliException e) {
43773       {
43774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43775       };
43776     } catch (...) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43779       };
43780     }
43781   }
43782
43783 }
43784
43785
43786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43787   Dali::Path *arg1 = (Dali::Path *) 0 ;
43788   float arg2 ;
43789
43790   arg1 = (Dali::Path *)jarg1;
43791   arg2 = (float)jarg2;
43792   {
43793     try {
43794       (arg1)->GenerateControlPoints(arg2);
43795     } catch (std::out_of_range& e) {
43796       {
43797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43798       };
43799     } catch (std::exception& e) {
43800       {
43801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43802       };
43803     } catch (Dali::DaliException e) {
43804       {
43805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43806       };
43807     } catch (...) {
43808       {
43809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43810       };
43811     }
43812   }
43813
43814 }
43815
43816
43817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43818   Dali::Path *arg1 = (Dali::Path *) 0 ;
43819   float arg2 ;
43820   Dali::Vector3 *arg3 = 0 ;
43821   Dali::Vector3 *arg4 = 0 ;
43822
43823   arg1 = (Dali::Path *)jarg1;
43824   arg2 = (float)jarg2;
43825   arg3 = (Dali::Vector3 *)jarg3;
43826   if (!arg3) {
43827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43828     return ;
43829   }
43830   arg4 = (Dali::Vector3 *)jarg4;
43831   if (!arg4) {
43832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43833     return ;
43834   }
43835   {
43836     try {
43837       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
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_GetPoint(void * jarg1, unsigned long jarg2) {
43861   void * jresult ;
43862   Dali::Path *arg1 = (Dali::Path *) 0 ;
43863   size_t arg2 ;
43864   Dali::Vector3 *result = 0 ;
43865
43866   arg1 = (Dali::Path *)jarg1;
43867   arg2 = (size_t)jarg2;
43868   {
43869     try {
43870       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43871     } catch (std::out_of_range& e) {
43872       {
43873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43874       };
43875     } catch (std::exception& e) {
43876       {
43877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43878       };
43879     } catch (Dali::DaliException e) {
43880       {
43881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43882       };
43883     } catch (...) {
43884       {
43885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43886       };
43887     }
43888   }
43889
43890   jresult = (void *)result;
43891   return jresult;
43892 }
43893
43894
43895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43896   void * jresult ;
43897   Dali::Path *arg1 = (Dali::Path *) 0 ;
43898   size_t arg2 ;
43899   Dali::Vector3 *result = 0 ;
43900
43901   arg1 = (Dali::Path *)jarg1;
43902   arg2 = (size_t)jarg2;
43903   {
43904     try {
43905       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43906     } catch (std::out_of_range& e) {
43907       {
43908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43909       };
43910     } catch (std::exception& e) {
43911       {
43912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43913       };
43914     } catch (Dali::DaliException e) {
43915       {
43916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43917       };
43918     } catch (...) {
43919       {
43920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43921       };
43922     }
43923   }
43924
43925   jresult = (void *)result;
43926   return jresult;
43927 }
43928
43929
43930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43931   unsigned long jresult ;
43932   Dali::Path *arg1 = (Dali::Path *) 0 ;
43933   size_t result;
43934
43935   arg1 = (Dali::Path *)jarg1;
43936   {
43937     try {
43938       result = ((Dali::Path const *)arg1)->GetPointCount();
43939     } catch (std::out_of_range& e) {
43940       {
43941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43942       };
43943     } catch (std::exception& e) {
43944       {
43945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43946       };
43947     } catch (Dali::DaliException e) {
43948       {
43949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43950       };
43951     } catch (...) {
43952       {
43953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43954       };
43955     }
43956   }
43957
43958   jresult = (unsigned long)result;
43959   return jresult;
43960 }
43961
43962
43963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43964   void * jresult ;
43965   float arg1 ;
43966   Dali::TimePeriod *result = 0 ;
43967
43968   arg1 = (float)jarg1;
43969   {
43970     try {
43971       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43972     } catch (std::out_of_range& e) {
43973       {
43974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43975       };
43976     } catch (std::exception& e) {
43977       {
43978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43979       };
43980     } catch (Dali::DaliException e) {
43981       {
43982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43983       };
43984     } catch (...) {
43985       {
43986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43987       };
43988     }
43989   }
43990
43991   jresult = (void *)result;
43992   return jresult;
43993 }
43994
43995
43996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43997   void * jresult ;
43998   float arg1 ;
43999   float arg2 ;
44000   Dali::TimePeriod *result = 0 ;
44001
44002   arg1 = (float)jarg1;
44003   arg2 = (float)jarg2;
44004   {
44005     try {
44006       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44007     } catch (std::out_of_range& e) {
44008       {
44009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44010       };
44011     } catch (std::exception& e) {
44012       {
44013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44014       };
44015     } catch (Dali::DaliException e) {
44016       {
44017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44018       };
44019     } catch (...) {
44020       {
44021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44022       };
44023     }
44024   }
44025
44026   jresult = (void *)result;
44027   return jresult;
44028 }
44029
44030
44031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44032   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44033
44034   arg1 = (Dali::TimePeriod *)jarg1;
44035   {
44036     try {
44037       delete arg1;
44038     } catch (std::out_of_range& e) {
44039       {
44040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44041       };
44042     } catch (std::exception& e) {
44043       {
44044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44045       };
44046     } catch (Dali::DaliException e) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44049       };
44050     } catch (...) {
44051       {
44052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44053       };
44054     }
44055   }
44056
44057 }
44058
44059
44060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44061   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44062   float arg2 ;
44063
44064   arg1 = (Dali::TimePeriod *)jarg1;
44065   arg2 = (float)jarg2;
44066   if (arg1) (arg1)->delaySeconds = arg2;
44067 }
44068
44069
44070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44071   float jresult ;
44072   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44073   float result;
44074
44075   arg1 = (Dali::TimePeriod *)jarg1;
44076   result = (float) ((arg1)->delaySeconds);
44077   jresult = result;
44078   return jresult;
44079 }
44080
44081
44082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44083   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44084   float arg2 ;
44085
44086   arg1 = (Dali::TimePeriod *)jarg1;
44087   arg2 = (float)jarg2;
44088   if (arg1) (arg1)->durationSeconds = arg2;
44089 }
44090
44091
44092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44093   float jresult ;
44094   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44095   float result;
44096
44097   arg1 = (Dali::TimePeriod *)jarg1;
44098   result = (float) ((arg1)->durationSeconds);
44099   jresult = result;
44100   return jresult;
44101 }
44102
44103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44104   int jresult ;
44105   int result;
44106
44107   result = (int)Dali::LinearConstrainer::Property::VALUE;
44108   jresult = (int)result;
44109   return jresult;
44110 }
44111
44112
44113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44114   int jresult ;
44115   int result;
44116
44117   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44118   jresult = (int)result;
44119   return jresult;
44120 }
44121
44122
44123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44124   void * jresult ;
44125   Dali::LinearConstrainer::Property *result = 0 ;
44126
44127   {
44128     try {
44129       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44130     } catch (std::out_of_range& e) {
44131       {
44132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44133       };
44134     } catch (std::exception& e) {
44135       {
44136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44137       };
44138     } catch (Dali::DaliException e) {
44139       {
44140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44141       };
44142     } catch (...) {
44143       {
44144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44145       };
44146     }
44147   }
44148
44149   jresult = (void *)result;
44150   return jresult;
44151 }
44152
44153
44154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44155   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44156
44157   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44158   {
44159     try {
44160       delete arg1;
44161     } catch (std::out_of_range& e) {
44162       {
44163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44164       };
44165     } catch (std::exception& e) {
44166       {
44167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44168       };
44169     } catch (Dali::DaliException e) {
44170       {
44171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44172       };
44173     } catch (...) {
44174       {
44175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44176       };
44177     }
44178   }
44179
44180 }
44181
44182
44183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44184   void * jresult ;
44185   Dali::LinearConstrainer result;
44186
44187   {
44188     try {
44189       result = Dali::LinearConstrainer::New();
44190     } catch (std::out_of_range& e) {
44191       {
44192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44193       };
44194     } catch (std::exception& e) {
44195       {
44196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44197       };
44198     } catch (Dali::DaliException e) {
44199       {
44200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44201       };
44202     } catch (...) {
44203       {
44204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44205       };
44206     }
44207   }
44208
44209   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44210   return jresult;
44211 }
44212
44213
44214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44215   void * jresult ;
44216   Dali::BaseHandle arg1 ;
44217   Dali::BaseHandle *argp1 ;
44218   Dali::LinearConstrainer result;
44219
44220   argp1 = (Dali::BaseHandle *)jarg1;
44221   if (!argp1) {
44222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44223     return 0;
44224   }
44225   arg1 = *argp1;
44226   {
44227     try {
44228       result = Dali::LinearConstrainer::DownCast(arg1);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44236       };
44237     } catch (Dali::DaliException e) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44240       };
44241     } catch (...) {
44242       {
44243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44244       };
44245     }
44246   }
44247
44248   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44249   return jresult;
44250 }
44251
44252
44253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44254   void * jresult ;
44255   Dali::LinearConstrainer *result = 0 ;
44256
44257   {
44258     try {
44259       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44260     } catch (std::out_of_range& e) {
44261       {
44262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44263       };
44264     } catch (std::exception& e) {
44265       {
44266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44267       };
44268     } catch (Dali::DaliException e) {
44269       {
44270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44271       };
44272     } catch (...) {
44273       {
44274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44275       };
44276     }
44277   }
44278
44279   jresult = (void *)result;
44280   return jresult;
44281 }
44282
44283
44284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44285   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44286
44287   arg1 = (Dali::LinearConstrainer *)jarg1;
44288   {
44289     try {
44290       delete arg1;
44291     } catch (std::out_of_range& e) {
44292       {
44293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44294       };
44295     } catch (std::exception& e) {
44296       {
44297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44298       };
44299     } catch (Dali::DaliException e) {
44300       {
44301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44302       };
44303     } catch (...) {
44304       {
44305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44306       };
44307     }
44308   }
44309
44310 }
44311
44312
44313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44314   void * jresult ;
44315   Dali::LinearConstrainer *arg1 = 0 ;
44316   Dali::LinearConstrainer *result = 0 ;
44317
44318   arg1 = (Dali::LinearConstrainer *)jarg1;
44319   if (!arg1) {
44320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44321     return 0;
44322   }
44323   {
44324     try {
44325       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44326     } catch (std::out_of_range& e) {
44327       {
44328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44329       };
44330     } catch (std::exception& e) {
44331       {
44332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44333       };
44334     } catch (Dali::DaliException e) {
44335       {
44336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44337       };
44338     } catch (...) {
44339       {
44340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44341       };
44342     }
44343   }
44344
44345   jresult = (void *)result;
44346   return jresult;
44347 }
44348
44349
44350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44351   void * jresult ;
44352   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44353   Dali::LinearConstrainer *arg2 = 0 ;
44354   Dali::LinearConstrainer *result = 0 ;
44355
44356   arg1 = (Dali::LinearConstrainer *)jarg1;
44357   arg2 = (Dali::LinearConstrainer *)jarg2;
44358   if (!arg2) {
44359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44360     return 0;
44361   }
44362   {
44363     try {
44364       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44365     } catch (std::out_of_range& e) {
44366       {
44367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44368       };
44369     } catch (std::exception& e) {
44370       {
44371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44372       };
44373     } catch (Dali::DaliException e) {
44374       {
44375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44376       };
44377     } catch (...) {
44378       {
44379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44380       };
44381     }
44382   }
44383
44384   jresult = (void *)result;
44385   return jresult;
44386 }
44387
44388
44389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44390   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44391   SwigValueWrapper< Dali::Property > arg2 ;
44392   SwigValueWrapper< Dali::Property > arg3 ;
44393   Dali::Vector2 *arg4 = 0 ;
44394   Dali::Vector2 *arg5 = 0 ;
44395   Dali::Property *argp2 ;
44396   Dali::Property *argp3 ;
44397
44398   arg1 = (Dali::LinearConstrainer *)jarg1;
44399   argp2 = (Dali::Property *)jarg2;
44400   if (!argp2) {
44401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44402     return ;
44403   }
44404   arg2 = *argp2;
44405   argp3 = (Dali::Property *)jarg3;
44406   if (!argp3) {
44407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44408     return ;
44409   }
44410   arg3 = *argp3;
44411   arg4 = (Dali::Vector2 *)jarg4;
44412   if (!arg4) {
44413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44414     return ;
44415   }
44416   arg5 = (Dali::Vector2 *)jarg5;
44417   if (!arg5) {
44418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44419     return ;
44420   }
44421   {
44422     try {
44423       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44424     } catch (std::out_of_range& e) {
44425       {
44426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44427       };
44428     } catch (std::exception& e) {
44429       {
44430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44431       };
44432     } catch (Dali::DaliException e) {
44433       {
44434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44435       };
44436     } catch (...) {
44437       {
44438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44439       };
44440     }
44441   }
44442
44443 }
44444
44445
44446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44447   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44448   SwigValueWrapper< Dali::Property > arg2 ;
44449   SwigValueWrapper< Dali::Property > arg3 ;
44450   Dali::Vector2 *arg4 = 0 ;
44451   Dali::Property *argp2 ;
44452   Dali::Property *argp3 ;
44453
44454   arg1 = (Dali::LinearConstrainer *)jarg1;
44455   argp2 = (Dali::Property *)jarg2;
44456   if (!argp2) {
44457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44458     return ;
44459   }
44460   arg2 = *argp2;
44461   argp3 = (Dali::Property *)jarg3;
44462   if (!argp3) {
44463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44464     return ;
44465   }
44466   arg3 = *argp3;
44467   arg4 = (Dali::Vector2 *)jarg4;
44468   if (!arg4) {
44469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44470     return ;
44471   }
44472   {
44473     try {
44474       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44475     } catch (std::out_of_range& e) {
44476       {
44477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44478       };
44479     } catch (std::exception& e) {
44480       {
44481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44482       };
44483     } catch (Dali::DaliException e) {
44484       {
44485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44486       };
44487     } catch (...) {
44488       {
44489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44490       };
44491     }
44492   }
44493
44494 }
44495
44496
44497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44498   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44499   Dali::Handle *arg2 = 0 ;
44500
44501   arg1 = (Dali::LinearConstrainer *)jarg1;
44502   arg2 = (Dali::Handle *)jarg2;
44503   if (!arg2) {
44504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44505     return ;
44506   }
44507   {
44508     try {
44509       (arg1)->Remove(*arg2);
44510     } catch (std::out_of_range& e) {
44511       {
44512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44513       };
44514     } catch (std::exception& e) {
44515       {
44516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44517       };
44518     } catch (Dali::DaliException e) {
44519       {
44520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44521       };
44522     } catch (...) {
44523       {
44524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44525       };
44526     }
44527   }
44528
44529 }
44530
44531
44532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44533   int jresult ;
44534   int result;
44535
44536   result = (int)Dali::PathConstrainer::Property::FORWARD;
44537   jresult = (int)result;
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44543   int jresult ;
44544   int result;
44545
44546   result = (int)Dali::PathConstrainer::Property::POINTS;
44547   jresult = (int)result;
44548   return jresult;
44549 }
44550
44551
44552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44553   int jresult ;
44554   int result;
44555
44556   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44557   jresult = (int)result;
44558   return jresult;
44559 }
44560
44561
44562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44563   void * jresult ;
44564   Dali::PathConstrainer::Property *result = 0 ;
44565
44566   {
44567     try {
44568       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44569     } catch (std::out_of_range& e) {
44570       {
44571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44572       };
44573     } catch (std::exception& e) {
44574       {
44575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44576       };
44577     } catch (Dali::DaliException e) {
44578       {
44579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44580       };
44581     } catch (...) {
44582       {
44583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44584       };
44585     }
44586   }
44587
44588   jresult = (void *)result;
44589   return jresult;
44590 }
44591
44592
44593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44594   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44595
44596   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44597   {
44598     try {
44599       delete arg1;
44600     } catch (std::out_of_range& e) {
44601       {
44602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44603       };
44604     } catch (std::exception& e) {
44605       {
44606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44607       };
44608     } catch (Dali::DaliException e) {
44609       {
44610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44611       };
44612     } catch (...) {
44613       {
44614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44615       };
44616     }
44617   }
44618
44619 }
44620
44621
44622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44623   void * jresult ;
44624   Dali::PathConstrainer result;
44625
44626   {
44627     try {
44628       result = Dali::PathConstrainer::New();
44629     } catch (std::out_of_range& e) {
44630       {
44631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44632       };
44633     } catch (std::exception& e) {
44634       {
44635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44636       };
44637     } catch (Dali::DaliException e) {
44638       {
44639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44640       };
44641     } catch (...) {
44642       {
44643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44644       };
44645     }
44646   }
44647
44648   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44649   return jresult;
44650 }
44651
44652
44653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44654   void * jresult ;
44655   Dali::BaseHandle arg1 ;
44656   Dali::BaseHandle *argp1 ;
44657   Dali::PathConstrainer result;
44658
44659   argp1 = (Dali::BaseHandle *)jarg1;
44660   if (!argp1) {
44661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44662     return 0;
44663   }
44664   arg1 = *argp1;
44665   {
44666     try {
44667       result = Dali::PathConstrainer::DownCast(arg1);
44668     } catch (std::out_of_range& e) {
44669       {
44670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44671       };
44672     } catch (std::exception& e) {
44673       {
44674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44675       };
44676     } catch (Dali::DaliException e) {
44677       {
44678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44679       };
44680     } catch (...) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44683       };
44684     }
44685   }
44686
44687   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44688   return jresult;
44689 }
44690
44691
44692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44693   void * jresult ;
44694   Dali::PathConstrainer *result = 0 ;
44695
44696   {
44697     try {
44698       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44699     } catch (std::out_of_range& e) {
44700       {
44701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44702       };
44703     } catch (std::exception& e) {
44704       {
44705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44706       };
44707     } catch (Dali::DaliException e) {
44708       {
44709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44710       };
44711     } catch (...) {
44712       {
44713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44714       };
44715     }
44716   }
44717
44718   jresult = (void *)result;
44719   return jresult;
44720 }
44721
44722
44723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44724   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44725
44726   arg1 = (Dali::PathConstrainer *)jarg1;
44727   {
44728     try {
44729       delete arg1;
44730     } catch (std::out_of_range& e) {
44731       {
44732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44733       };
44734     } catch (std::exception& e) {
44735       {
44736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44737       };
44738     } catch (Dali::DaliException e) {
44739       {
44740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44741       };
44742     } catch (...) {
44743       {
44744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44745       };
44746     }
44747   }
44748
44749 }
44750
44751
44752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44753   void * jresult ;
44754   Dali::PathConstrainer *arg1 = 0 ;
44755   Dali::PathConstrainer *result = 0 ;
44756
44757   arg1 = (Dali::PathConstrainer *)jarg1;
44758   if (!arg1) {
44759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44760     return 0;
44761   }
44762   {
44763     try {
44764       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44765     } catch (std::out_of_range& e) {
44766       {
44767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44768       };
44769     } catch (std::exception& e) {
44770       {
44771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44772       };
44773     } catch (Dali::DaliException e) {
44774       {
44775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44776       };
44777     } catch (...) {
44778       {
44779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44780       };
44781     }
44782   }
44783
44784   jresult = (void *)result;
44785   return jresult;
44786 }
44787
44788
44789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44790   void * jresult ;
44791   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44792   Dali::PathConstrainer *arg2 = 0 ;
44793   Dali::PathConstrainer *result = 0 ;
44794
44795   arg1 = (Dali::PathConstrainer *)jarg1;
44796   arg2 = (Dali::PathConstrainer *)jarg2;
44797   if (!arg2) {
44798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44799     return 0;
44800   }
44801   {
44802     try {
44803       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44804     } catch (std::out_of_range& e) {
44805       {
44806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44807       };
44808     } catch (std::exception& e) {
44809       {
44810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44811       };
44812     } catch (Dali::DaliException e) {
44813       {
44814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44815       };
44816     } catch (...) {
44817       {
44818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44819       };
44820     }
44821   }
44822
44823   jresult = (void *)result;
44824   return jresult;
44825 }
44826
44827
44828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44829   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44830   SwigValueWrapper< Dali::Property > arg2 ;
44831   SwigValueWrapper< Dali::Property > arg3 ;
44832   Dali::Vector2 *arg4 = 0 ;
44833   Dali::Vector2 *arg5 = 0 ;
44834   Dali::Property *argp2 ;
44835   Dali::Property *argp3 ;
44836
44837   arg1 = (Dali::PathConstrainer *)jarg1;
44838   argp2 = (Dali::Property *)jarg2;
44839   if (!argp2) {
44840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44841     return ;
44842   }
44843   arg2 = *argp2;
44844   argp3 = (Dali::Property *)jarg3;
44845   if (!argp3) {
44846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44847     return ;
44848   }
44849   arg3 = *argp3;
44850   arg4 = (Dali::Vector2 *)jarg4;
44851   if (!arg4) {
44852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44853     return ;
44854   }
44855   arg5 = (Dali::Vector2 *)jarg5;
44856   if (!arg5) {
44857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44858     return ;
44859   }
44860   {
44861     try {
44862       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44863     } catch (std::out_of_range& e) {
44864       {
44865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44866       };
44867     } catch (std::exception& e) {
44868       {
44869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44870       };
44871     } catch (Dali::DaliException e) {
44872       {
44873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44874       };
44875     } catch (...) {
44876       {
44877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44878       };
44879     }
44880   }
44881
44882 }
44883
44884
44885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44886   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44887   SwigValueWrapper< Dali::Property > arg2 ;
44888   SwigValueWrapper< Dali::Property > arg3 ;
44889   Dali::Vector2 *arg4 = 0 ;
44890   Dali::Property *argp2 ;
44891   Dali::Property *argp3 ;
44892
44893   arg1 = (Dali::PathConstrainer *)jarg1;
44894   argp2 = (Dali::Property *)jarg2;
44895   if (!argp2) {
44896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44897     return ;
44898   }
44899   arg2 = *argp2;
44900   argp3 = (Dali::Property *)jarg3;
44901   if (!argp3) {
44902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44903     return ;
44904   }
44905   arg3 = *argp3;
44906   arg4 = (Dali::Vector2 *)jarg4;
44907   if (!arg4) {
44908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44909     return ;
44910   }
44911   {
44912     try {
44913       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44914     } catch (std::out_of_range& e) {
44915       {
44916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44917       };
44918     } catch (std::exception& e) {
44919       {
44920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44921       };
44922     } catch (Dali::DaliException e) {
44923       {
44924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44925       };
44926     } catch (...) {
44927       {
44928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44929       };
44930     }
44931   }
44932
44933 }
44934
44935
44936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44937   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44938   Dali::Handle *arg2 = 0 ;
44939
44940   arg1 = (Dali::PathConstrainer *)jarg1;
44941   arg2 = (Dali::Handle *)jarg2;
44942   if (!arg2) {
44943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44944     return ;
44945   }
44946   {
44947     try {
44948       (arg1)->Remove(*arg2);
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44964       };
44965     }
44966   }
44967
44968 }
44969
44970
44971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44972   int jresult ;
44973   Dali::FittingMode::Type result;
44974
44975   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44976   jresult = (int)result;
44977   return jresult;
44978 }
44979
44980
44981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44982   int jresult ;
44983   Dali::SamplingMode::Type result;
44984
44985   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44986   jresult = (int)result;
44987   return jresult;
44988 }
44989
44990
44991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44992   void * jresult ;
44993   Dali::BufferImage *result = 0 ;
44994
44995   {
44996     try {
44997       result = (Dali::BufferImage *)new Dali::BufferImage();
44998     } catch (std::out_of_range& e) {
44999       {
45000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45001       };
45002     } catch (std::exception& e) {
45003       {
45004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45005       };
45006     } catch (Dali::DaliException e) {
45007       {
45008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45009       };
45010     } catch (...) {
45011       {
45012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45013       };
45014     }
45015   }
45016
45017   jresult = (void *)result;
45018   return jresult;
45019 }
45020
45021
45022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45023   void * jresult ;
45024   unsigned int arg1 ;
45025   unsigned int arg2 ;
45026   Dali::Pixel::Format arg3 ;
45027   Dali::BufferImage result;
45028
45029   arg1 = (unsigned int)jarg1;
45030   arg2 = (unsigned int)jarg2;
45031   arg3 = (Dali::Pixel::Format)jarg3;
45032   {
45033     try {
45034       result = Dali::BufferImage::New(arg1,arg2,arg3);
45035     } catch (std::out_of_range& e) {
45036       {
45037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45038       };
45039     } catch (std::exception& e) {
45040       {
45041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45042       };
45043     } catch (Dali::DaliException e) {
45044       {
45045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45046       };
45047     } catch (...) {
45048       {
45049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45050       };
45051     }
45052   }
45053
45054   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45055   return jresult;
45056 }
45057
45058
45059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45060   void * jresult ;
45061   unsigned int arg1 ;
45062   unsigned int arg2 ;
45063   Dali::BufferImage result;
45064
45065   arg1 = (unsigned int)jarg1;
45066   arg2 = (unsigned int)jarg2;
45067   {
45068     try {
45069       result = Dali::BufferImage::New(arg1,arg2);
45070     } catch (std::out_of_range& e) {
45071       {
45072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45073       };
45074     } catch (std::exception& e) {
45075       {
45076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45077       };
45078     } catch (Dali::DaliException e) {
45079       {
45080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45081       };
45082     } catch (...) {
45083       {
45084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45085       };
45086     }
45087   }
45088
45089   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45090   return jresult;
45091 }
45092
45093
45094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45095   void * jresult ;
45096   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45097   unsigned int arg2 ;
45098   unsigned int arg3 ;
45099   Dali::Pixel::Format arg4 ;
45100   unsigned int arg5 ;
45101   Dali::BufferImage result;
45102
45103   arg1 = jarg1;
45104   arg2 = (unsigned int)jarg2;
45105   arg3 = (unsigned int)jarg3;
45106   arg4 = (Dali::Pixel::Format)jarg4;
45107   arg5 = (unsigned int)jarg5;
45108   {
45109     try {
45110       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45111     } catch (std::out_of_range& e) {
45112       {
45113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (std::exception& e) {
45116       {
45117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45118       };
45119     } catch (Dali::DaliException e) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45122       };
45123     } catch (...) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45126       };
45127     }
45128   }
45129
45130   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45131
45132
45133   return jresult;
45134 }
45135
45136
45137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45138   void * jresult ;
45139   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45140   unsigned int arg2 ;
45141   unsigned int arg3 ;
45142   Dali::Pixel::Format arg4 ;
45143   Dali::BufferImage result;
45144
45145   arg1 = jarg1;
45146   arg2 = (unsigned int)jarg2;
45147   arg3 = (unsigned int)jarg3;
45148   arg4 = (Dali::Pixel::Format)jarg4;
45149   {
45150     try {
45151       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45152     } catch (std::out_of_range& e) {
45153       {
45154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45155       };
45156     } catch (std::exception& e) {
45157       {
45158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45159       };
45160     } catch (Dali::DaliException e) {
45161       {
45162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45163       };
45164     } catch (...) {
45165       {
45166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45167       };
45168     }
45169   }
45170
45171   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45172
45173
45174   return jresult;
45175 }
45176
45177
45178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45179   void * jresult ;
45180   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45181   unsigned int arg2 ;
45182   unsigned int arg3 ;
45183   Dali::BufferImage result;
45184
45185   arg1 = jarg1;
45186   arg2 = (unsigned int)jarg2;
45187   arg3 = (unsigned int)jarg3;
45188   {
45189     try {
45190       result = Dali::BufferImage::New(arg1,arg2,arg3);
45191     } catch (std::out_of_range& e) {
45192       {
45193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45194       };
45195     } catch (std::exception& e) {
45196       {
45197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45198       };
45199     } catch (Dali::DaliException e) {
45200       {
45201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45202       };
45203     } catch (...) {
45204       {
45205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45206       };
45207     }
45208   }
45209
45210   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45211
45212
45213   return jresult;
45214 }
45215
45216
45217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_DownCast(void * jarg1) {
45218   void * jresult ;
45219   Dali::BaseHandle arg1 ;
45220   Dali::BaseHandle *argp1 ;
45221   Dali::BufferImage result;
45222
45223   argp1 = (Dali::BaseHandle *)jarg1;
45224   if (!argp1) {
45225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45226     return 0;
45227   }
45228   arg1 = *argp1;
45229   {
45230     try {
45231       result = Dali::BufferImage::DownCast(arg1);
45232     } catch (std::out_of_range& e) {
45233       {
45234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45235       };
45236     } catch (std::exception& e) {
45237       {
45238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45239       };
45240     } catch (Dali::DaliException e) {
45241       {
45242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45243       };
45244     } catch (...) {
45245       {
45246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45247       };
45248     }
45249   }
45250
45251   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45252   return jresult;
45253 }
45254
45255
45256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45257   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45258
45259   arg1 = (Dali::BufferImage *)jarg1;
45260   {
45261     try {
45262       delete arg1;
45263     } catch (std::out_of_range& e) {
45264       {
45265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45266       };
45267     } catch (std::exception& e) {
45268       {
45269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45270       };
45271     } catch (Dali::DaliException e) {
45272       {
45273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45274       };
45275     } catch (...) {
45276       {
45277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45278       };
45279     }
45280   }
45281
45282 }
45283
45284
45285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45286   void * jresult ;
45287   Dali::BufferImage *arg1 = 0 ;
45288   Dali::BufferImage *result = 0 ;
45289
45290   arg1 = (Dali::BufferImage *)jarg1;
45291   if (!arg1) {
45292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45293     return 0;
45294   }
45295   {
45296     try {
45297       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45298     } catch (std::out_of_range& e) {
45299       {
45300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45301       };
45302     } catch (std::exception& e) {
45303       {
45304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45305       };
45306     } catch (Dali::DaliException e) {
45307       {
45308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45309       };
45310     } catch (...) {
45311       {
45312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45313       };
45314     }
45315   }
45316
45317   jresult = (void *)result;
45318   return jresult;
45319 }
45320
45321
45322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45323   void * jresult ;
45324   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45325   Dali::BufferImage *arg2 = 0 ;
45326   Dali::BufferImage *result = 0 ;
45327
45328   arg1 = (Dali::BufferImage *)jarg1;
45329   arg2 = (Dali::BufferImage *)jarg2;
45330   if (!arg2) {
45331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45332     return 0;
45333   }
45334   {
45335     try {
45336       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
45337     } catch (std::out_of_range& e) {
45338       {
45339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45340       };
45341     } catch (std::exception& e) {
45342       {
45343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45344       };
45345     } catch (Dali::DaliException e) {
45346       {
45347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45348       };
45349     } catch (...) {
45350       {
45351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45352       };
45353     }
45354   }
45355
45356   jresult = (void *)result;
45357   return jresult;
45358 }
45359
45360
45361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_WHITE() {
45362   void * jresult ;
45363   Dali::BufferImage result;
45364
45365   {
45366     try {
45367       result = Dali::BufferImage::WHITE();
45368     } catch (std::out_of_range& e) {
45369       {
45370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45371       };
45372     } catch (std::exception& e) {
45373       {
45374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45375       };
45376     } catch (Dali::DaliException e) {
45377       {
45378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45379       };
45380     } catch (...) {
45381       {
45382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45383       };
45384     }
45385   }
45386
45387   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45388   return jresult;
45389 }
45390
45391
45392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45393   void * jresult ;
45394   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45395   Dali::PixelBuffer *result = 0 ;
45396
45397   arg1 = (Dali::BufferImage *)jarg1;
45398   {
45399     try {
45400       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45401     } catch (std::out_of_range& e) {
45402       {
45403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45404       };
45405     } catch (std::exception& e) {
45406       {
45407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45408       };
45409     } catch (Dali::DaliException e) {
45410       {
45411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45412       };
45413     } catch (...) {
45414       {
45415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45416       };
45417     }
45418   }
45419
45420   jresult = (void *)result;
45421   return jresult;
45422 }
45423
45424
45425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45426   unsigned int jresult ;
45427   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45428   unsigned int result;
45429
45430   arg1 = (Dali::BufferImage *)jarg1;
45431   {
45432     try {
45433       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45434     } catch (std::out_of_range& e) {
45435       {
45436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45437       };
45438     } catch (std::exception& e) {
45439       {
45440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45441       };
45442     } catch (Dali::DaliException e) {
45443       {
45444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45445       };
45446     } catch (...) {
45447       {
45448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45449       };
45450     }
45451   }
45452
45453   jresult = result;
45454   return jresult;
45455 }
45456
45457
45458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45459   unsigned int jresult ;
45460   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45461   unsigned int result;
45462
45463   arg1 = (Dali::BufferImage *)jarg1;
45464   {
45465     try {
45466       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45467     } catch (std::out_of_range& e) {
45468       {
45469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45470       };
45471     } catch (std::exception& e) {
45472       {
45473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45474       };
45475     } catch (Dali::DaliException e) {
45476       {
45477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45478       };
45479     } catch (...) {
45480       {
45481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45482       };
45483     }
45484   }
45485
45486   jresult = result;
45487   return jresult;
45488 }
45489
45490
45491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45492   int jresult ;
45493   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45494   Dali::Pixel::Format result;
45495
45496   arg1 = (Dali::BufferImage *)jarg1;
45497   {
45498     try {
45499       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45500     } catch (std::out_of_range& e) {
45501       {
45502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45503       };
45504     } catch (std::exception& e) {
45505       {
45506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45507       };
45508     } catch (Dali::DaliException e) {
45509       {
45510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45511       };
45512     } catch (...) {
45513       {
45514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45515       };
45516     }
45517   }
45518
45519   jresult = (int)result;
45520   return jresult;
45521 }
45522
45523
45524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45525   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45526
45527   arg1 = (Dali::BufferImage *)jarg1;
45528   {
45529     try {
45530       (arg1)->Update();
45531     } catch (std::out_of_range& e) {
45532       {
45533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45534       };
45535     } catch (std::exception& e) {
45536       {
45537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45538       };
45539     } catch (Dali::DaliException e) {
45540       {
45541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45542       };
45543     } catch (...) {
45544       {
45545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45546       };
45547     }
45548   }
45549
45550 }
45551
45552
45553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45554   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45555   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45556   Dali::RectArea *argp2 ;
45557
45558   arg1 = (Dali::BufferImage *)jarg1;
45559   argp2 = (Dali::RectArea *)jarg2;
45560   if (!argp2) {
45561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45562     return ;
45563   }
45564   arg2 = *argp2;
45565   {
45566     try {
45567       (arg1)->Update(arg2);
45568     } catch (std::out_of_range& e) {
45569       {
45570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45571       };
45572     } catch (std::exception& e) {
45573       {
45574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45575       };
45576     } catch (Dali::DaliException e) {
45577       {
45578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45579       };
45580     } catch (...) {
45581       {
45582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45583       };
45584     }
45585   }
45586
45587 }
45588
45589
45590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45591   unsigned int jresult ;
45592   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45593   bool result;
45594
45595   arg1 = (Dali::BufferImage *)jarg1;
45596   {
45597     try {
45598       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45599     } catch (std::out_of_range& e) {
45600       {
45601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45602       };
45603     } catch (std::exception& e) {
45604       {
45605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45606       };
45607     } catch (Dali::DaliException e) {
45608       {
45609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45610       };
45611     } catch (...) {
45612       {
45613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45614       };
45615     }
45616   }
45617
45618   jresult = result;
45619   return jresult;
45620 }
45621
45622
45623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45624   void * jresult ;
45625   Dali::EncodedBufferImage *result = 0 ;
45626
45627   {
45628     try {
45629       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45630     } catch (std::out_of_range& e) {
45631       {
45632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (std::exception& e) {
45635       {
45636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (Dali::DaliException e) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45641       };
45642     } catch (...) {
45643       {
45644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45645       };
45646     }
45647   }
45648
45649   jresult = (void *)result;
45650   return jresult;
45651 }
45652
45653
45654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45655   void * jresult ;
45656   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45657   std::size_t arg2 ;
45658   Dali::EncodedBufferImage result;
45659
45660   arg1 = (uint8_t *)jarg1;
45661   arg2 = (std::size_t)jarg2;
45662   {
45663     try {
45664       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45665     } catch (std::out_of_range& e) {
45666       {
45667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45668       };
45669     } catch (std::exception& e) {
45670       {
45671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45672       };
45673     } catch (Dali::DaliException e) {
45674       {
45675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45676       };
45677     } catch (...) {
45678       {
45679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45680       };
45681     }
45682   }
45683
45684   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45685   return jresult;
45686 }
45687
45688
45689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45690   void * jresult ;
45691   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45692   std::size_t arg2 ;
45693   Dali::ImageDimensions arg3 ;
45694   Dali::FittingMode::Type arg4 ;
45695   Dali::SamplingMode::Type arg5 ;
45696   bool arg6 ;
45697   Dali::ImageDimensions *argp3 ;
45698   Dali::EncodedBufferImage result;
45699
45700   arg1 = (uint8_t *)jarg1;
45701   arg2 = (std::size_t)jarg2;
45702   argp3 = (Dali::ImageDimensions *)jarg3;
45703   if (!argp3) {
45704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45705     return 0;
45706   }
45707   arg3 = *argp3;
45708   arg4 = (Dali::FittingMode::Type)jarg4;
45709   arg5 = (Dali::SamplingMode::Type)jarg5;
45710   arg6 = jarg6 ? true : false;
45711   {
45712     try {
45713       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45714     } catch (std::out_of_range& e) {
45715       {
45716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45717       };
45718     } catch (std::exception& e) {
45719       {
45720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45721       };
45722     } catch (Dali::DaliException e) {
45723       {
45724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45725       };
45726     } catch (...) {
45727       {
45728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45729       };
45730     }
45731   }
45732
45733   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45734   return jresult;
45735 }
45736
45737
45738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45739   void * jresult ;
45740   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45741   std::size_t arg2 ;
45742   Dali::ImageDimensions arg3 ;
45743   Dali::FittingMode::Type arg4 ;
45744   Dali::SamplingMode::Type arg5 ;
45745   Dali::ImageDimensions *argp3 ;
45746   Dali::EncodedBufferImage result;
45747
45748   arg1 = (uint8_t *)jarg1;
45749   arg2 = (std::size_t)jarg2;
45750   argp3 = (Dali::ImageDimensions *)jarg3;
45751   if (!argp3) {
45752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45753     return 0;
45754   }
45755   arg3 = *argp3;
45756   arg4 = (Dali::FittingMode::Type)jarg4;
45757   arg5 = (Dali::SamplingMode::Type)jarg5;
45758   {
45759     try {
45760       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45761     } catch (std::out_of_range& e) {
45762       {
45763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45764       };
45765     } catch (std::exception& e) {
45766       {
45767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45768       };
45769     } catch (Dali::DaliException e) {
45770       {
45771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45772       };
45773     } catch (...) {
45774       {
45775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45776       };
45777     }
45778   }
45779
45780   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45781   return jresult;
45782 }
45783
45784
45785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45786   void * jresult ;
45787   Dali::BaseHandle arg1 ;
45788   Dali::BaseHandle *argp1 ;
45789   Dali::EncodedBufferImage result;
45790
45791   argp1 = (Dali::BaseHandle *)jarg1;
45792   if (!argp1) {
45793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45794     return 0;
45795   }
45796   arg1 = *argp1;
45797   {
45798     try {
45799       result = Dali::EncodedBufferImage::DownCast(arg1);
45800     } catch (std::out_of_range& e) {
45801       {
45802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45803       };
45804     } catch (std::exception& e) {
45805       {
45806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45807       };
45808     } catch (Dali::DaliException e) {
45809       {
45810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45811       };
45812     } catch (...) {
45813       {
45814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45815       };
45816     }
45817   }
45818
45819   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45820   return jresult;
45821 }
45822
45823
45824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_EncodedBufferImage(void * jarg1) {
45825   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45826
45827   arg1 = (Dali::EncodedBufferImage *)jarg1;
45828   {
45829     try {
45830       delete arg1;
45831     } catch (std::out_of_range& e) {
45832       {
45833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45834       };
45835     } catch (std::exception& e) {
45836       {
45837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45838       };
45839     } catch (Dali::DaliException e) {
45840       {
45841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45842       };
45843     } catch (...) {
45844       {
45845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45846       };
45847     }
45848   }
45849
45850 }
45851
45852
45853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45854   void * jresult ;
45855   Dali::EncodedBufferImage *arg1 = 0 ;
45856   Dali::EncodedBufferImage *result = 0 ;
45857
45858   arg1 = (Dali::EncodedBufferImage *)jarg1;
45859   if (!arg1) {
45860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45861     return 0;
45862   }
45863   {
45864     try {
45865       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45866     } catch (std::out_of_range& e) {
45867       {
45868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45869       };
45870     } catch (std::exception& e) {
45871       {
45872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45873       };
45874     } catch (Dali::DaliException e) {
45875       {
45876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45877       };
45878     } catch (...) {
45879       {
45880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45881       };
45882     }
45883   }
45884
45885   jresult = (void *)result;
45886   return jresult;
45887 }
45888
45889
45890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45891   void * jresult ;
45892   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45893   Dali::EncodedBufferImage *arg2 = 0 ;
45894   Dali::EncodedBufferImage *result = 0 ;
45895
45896   arg1 = (Dali::EncodedBufferImage *)jarg1;
45897   arg2 = (Dali::EncodedBufferImage *)jarg2;
45898   if (!arg2) {
45899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45900     return 0;
45901   }
45902   {
45903     try {
45904       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
45905     } catch (std::out_of_range& e) {
45906       {
45907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (std::exception& e) {
45910       {
45911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45912       };
45913     } catch (Dali::DaliException e) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45916       };
45917     } catch (...) {
45918       {
45919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45920       };
45921     }
45922   }
45923
45924   jresult = (void *)result;
45925   return jresult;
45926 }
45927
45928
45929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45930   void * jresult ;
45931   Dali::NativeImage *result = 0 ;
45932
45933   {
45934     try {
45935       result = (Dali::NativeImage *)new Dali::NativeImage();
45936     } catch (std::out_of_range& e) {
45937       {
45938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45939       };
45940     } catch (std::exception& e) {
45941       {
45942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45943       };
45944     } catch (Dali::DaliException e) {
45945       {
45946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45947       };
45948     } catch (...) {
45949       {
45950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45951       };
45952     }
45953   }
45954
45955   jresult = (void *)result;
45956   return jresult;
45957 }
45958
45959
45960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45961   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45962
45963   arg1 = (Dali::NativeImage *)jarg1;
45964   {
45965     try {
45966       delete arg1;
45967     } catch (std::out_of_range& e) {
45968       {
45969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45970       };
45971     } catch (std::exception& e) {
45972       {
45973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45974       };
45975     } catch (Dali::DaliException e) {
45976       {
45977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45978       };
45979     } catch (...) {
45980       {
45981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45982       };
45983     }
45984   }
45985
45986 }
45987
45988
45989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45990   void * jresult ;
45991   Dali::NativeImage *arg1 = 0 ;
45992   Dali::NativeImage *result = 0 ;
45993
45994   arg1 = (Dali::NativeImage *)jarg1;
45995   if (!arg1) {
45996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45997     return 0;
45998   }
45999   {
46000     try {
46001       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
46002     } catch (std::out_of_range& e) {
46003       {
46004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46005       };
46006     } catch (std::exception& e) {
46007       {
46008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46009       };
46010     } catch (Dali::DaliException e) {
46011       {
46012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46013       };
46014     } catch (...) {
46015       {
46016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46017       };
46018     }
46019   }
46020
46021   jresult = (void *)result;
46022   return jresult;
46023 }
46024
46025
46026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46027   void * jresult ;
46028   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46029   Dali::NativeImage *arg2 = 0 ;
46030   Dali::NativeImage *result = 0 ;
46031
46032   arg1 = (Dali::NativeImage *)jarg1;
46033   arg2 = (Dali::NativeImage *)jarg2;
46034   if (!arg2) {
46035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46036     return 0;
46037   }
46038   {
46039     try {
46040       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
46041     } catch (std::out_of_range& e) {
46042       {
46043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46044       };
46045     } catch (std::exception& e) {
46046       {
46047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46048       };
46049     } catch (Dali::DaliException e) {
46050       {
46051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46052       };
46053     } catch (...) {
46054       {
46055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46056       };
46057     }
46058   }
46059
46060   jresult = (void *)result;
46061   return jresult;
46062 }
46063
46064
46065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
46066   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46067
46068   arg1 = (Dali::NativeImage *)jarg1;
46069   {
46070     try {
46071       (arg1)->CreateGlTexture();
46072     } catch (std::out_of_range& e) {
46073       {
46074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46075       };
46076     } catch (std::exception& e) {
46077       {
46078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46079       };
46080     } catch (Dali::DaliException e) {
46081       {
46082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46083       };
46084     } catch (...) {
46085       {
46086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46087       };
46088     }
46089   }
46090
46091 }
46092
46093
46094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46095   void * jresult ;
46096   NativeImageInterface *arg1 = 0 ;
46097   Dali::NativeImage result;
46098
46099   arg1 = (NativeImageInterface *)jarg1;
46100   if (!arg1) {
46101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46102     return 0;
46103   }
46104   {
46105     try {
46106       result = Dali::NativeImage::New(*arg1);
46107     } catch (std::out_of_range& e) {
46108       {
46109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46110       };
46111     } catch (std::exception& e) {
46112       {
46113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46114       };
46115     } catch (Dali::DaliException e) {
46116       {
46117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46118       };
46119     } catch (...) {
46120       {
46121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46122       };
46123     }
46124   }
46125
46126   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46127   return jresult;
46128 }
46129
46130
46131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46132   void * jresult ;
46133   Dali::BaseHandle arg1 ;
46134   Dali::BaseHandle *argp1 ;
46135   Dali::NativeImage result;
46136
46137   argp1 = (Dali::BaseHandle *)jarg1;
46138   if (!argp1) {
46139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46140     return 0;
46141   }
46142   arg1 = *argp1;
46143   {
46144     try {
46145       result = Dali::NativeImage::DownCast(arg1);
46146     } catch (std::out_of_range& e) {
46147       {
46148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46149       };
46150     } catch (std::exception& e) {
46151       {
46152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46153       };
46154     } catch (Dali::DaliException e) {
46155       {
46156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46157       };
46158     } catch (...) {
46159       {
46160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46161       };
46162     }
46163   }
46164
46165   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46166   return jresult;
46167 }
46168
46169
46170 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46171   char * jresult ;
46172   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46173   char *result = 0 ;
46174
46175   arg1 = (Dali::NativeImage *)jarg1;
46176   {
46177     try {
46178       result = (char *)(arg1)->GetCustomFragmentPreFix();
46179     } catch (std::out_of_range& e) {
46180       {
46181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46182       };
46183     } catch (std::exception& e) {
46184       {
46185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46186       };
46187     } catch (Dali::DaliException e) {
46188       {
46189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46190       };
46191     } catch (...) {
46192       {
46193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46194       };
46195     }
46196   }
46197
46198   jresult = SWIG_csharp_string_callback((const char *)result);
46199   return jresult;
46200 }
46201
46202
46203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46204   char * jresult ;
46205   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46206   char *result = 0 ;
46207
46208   arg1 = (Dali::NativeImage *)jarg1;
46209   {
46210     try {
46211       result = (char *)(arg1)->GetCustomSamplerTypename();
46212     } catch (std::out_of_range& e) {
46213       {
46214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46215       };
46216     } catch (std::exception& e) {
46217       {
46218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46219       };
46220     } catch (Dali::DaliException e) {
46221       {
46222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46223       };
46224     } catch (...) {
46225       {
46226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46227       };
46228     }
46229   }
46230
46231   jresult = SWIG_csharp_string_callback((const char *)result);
46232   return jresult;
46233 }
46234
46235
46236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46237   unsigned int jresult ;
46238   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46239   bool result;
46240
46241   arg1 = (Dali::NativeImageInterface *)jarg1;
46242   {
46243     try {
46244       result = (bool)(arg1)->GlExtensionCreate();
46245     } catch (std::out_of_range& e) {
46246       {
46247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46248       };
46249     } catch (std::exception& e) {
46250       {
46251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46252       };
46253     } catch (Dali::DaliException e) {
46254       {
46255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46256       };
46257     } catch (...) {
46258       {
46259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46260       };
46261     }
46262   }
46263
46264   jresult = result;
46265   return jresult;
46266 }
46267
46268
46269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46270   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46271
46272   arg1 = (Dali::NativeImageInterface *)jarg1;
46273   {
46274     try {
46275       (arg1)->GlExtensionDestroy();
46276     } catch (std::out_of_range& e) {
46277       {
46278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46279       };
46280     } catch (std::exception& e) {
46281       {
46282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46283       };
46284     } catch (Dali::DaliException e) {
46285       {
46286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46287       };
46288     } catch (...) {
46289       {
46290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46291       };
46292     }
46293   }
46294
46295 }
46296
46297
46298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46299   unsigned int jresult ;
46300   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46301   unsigned int result;
46302
46303   arg1 = (Dali::NativeImageInterface *)jarg1;
46304   {
46305     try {
46306       result = (unsigned int)(arg1)->TargetTexture();
46307     } catch (std::out_of_range& e) {
46308       {
46309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46310       };
46311     } catch (std::exception& e) {
46312       {
46313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46314       };
46315     } catch (Dali::DaliException e) {
46316       {
46317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46318       };
46319     } catch (...) {
46320       {
46321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46322       };
46323     }
46324   }
46325
46326   jresult = result;
46327   return jresult;
46328 }
46329
46330
46331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46332   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46333
46334   arg1 = (Dali::NativeImageInterface *)jarg1;
46335   {
46336     try {
46337       (arg1)->PrepareTexture();
46338     } catch (std::out_of_range& e) {
46339       {
46340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46341       };
46342     } catch (std::exception& e) {
46343       {
46344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46345       };
46346     } catch (Dali::DaliException e) {
46347       {
46348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46349       };
46350     } catch (...) {
46351       {
46352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46353       };
46354     }
46355   }
46356
46357 }
46358
46359
46360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46361   unsigned int jresult ;
46362   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46363   unsigned int result;
46364
46365   arg1 = (Dali::NativeImageInterface *)jarg1;
46366   {
46367     try {
46368       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46369     } catch (std::out_of_range& e) {
46370       {
46371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46372       };
46373     } catch (std::exception& e) {
46374       {
46375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46376       };
46377     } catch (Dali::DaliException e) {
46378       {
46379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46380       };
46381     } catch (...) {
46382       {
46383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46384       };
46385     }
46386   }
46387
46388   jresult = result;
46389   return jresult;
46390 }
46391
46392
46393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46394   unsigned int jresult ;
46395   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46396   unsigned int result;
46397
46398   arg1 = (Dali::NativeImageInterface *)jarg1;
46399   {
46400     try {
46401       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46402     } catch (std::out_of_range& e) {
46403       {
46404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46405       };
46406     } catch (std::exception& e) {
46407       {
46408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46409       };
46410     } catch (Dali::DaliException e) {
46411       {
46412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46413       };
46414     } catch (...) {
46415       {
46416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46417       };
46418     }
46419   }
46420
46421   jresult = result;
46422   return jresult;
46423 }
46424
46425
46426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46427   unsigned int jresult ;
46428   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46429   bool result;
46430
46431   arg1 = (Dali::NativeImageInterface *)jarg1;
46432   {
46433     try {
46434       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46435     } catch (std::out_of_range& e) {
46436       {
46437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46438       };
46439     } catch (std::exception& e) {
46440       {
46441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46442       };
46443     } catch (Dali::DaliException e) {
46444       {
46445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46446       };
46447     } catch (...) {
46448       {
46449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46450       };
46451     }
46452   }
46453
46454   jresult = result;
46455   return jresult;
46456 }
46457
46458
46459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46460   void * jresult ;
46461   std::string *arg1 = 0 ;
46462   Dali::ImageDimensions result;
46463
46464   if (!jarg1) {
46465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46466     return 0;
46467   }
46468   std::string arg1_str(jarg1);
46469   arg1 = &arg1_str;
46470   {
46471     try {
46472       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46473     } catch (std::out_of_range& e) {
46474       {
46475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46476       };
46477     } catch (std::exception& e) {
46478       {
46479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46480       };
46481     } catch (Dali::DaliException e) {
46482       {
46483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46484       };
46485     } catch (...) {
46486       {
46487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46488       };
46489     }
46490   }
46491
46492   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46493
46494   //argout typemap for const std::string&
46495
46496   return jresult;
46497 }
46498
46499
46500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46501   void * jresult ;
46502   Dali::ResourceImage *result = 0 ;
46503
46504   {
46505     try {
46506       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46507     } catch (std::out_of_range& e) {
46508       {
46509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46510       };
46511     } catch (std::exception& e) {
46512       {
46513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46514       };
46515     } catch (Dali::DaliException e) {
46516       {
46517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46518       };
46519     } catch (...) {
46520       {
46521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46522       };
46523     }
46524   }
46525
46526   jresult = (void *)result;
46527   return jresult;
46528 }
46529
46530
46531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46532   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46533
46534   arg1 = (Dali::ResourceImage *)jarg1;
46535   {
46536     try {
46537       delete arg1;
46538     } catch (std::out_of_range& e) {
46539       {
46540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46541       };
46542     } catch (std::exception& e) {
46543       {
46544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46545       };
46546     } catch (Dali::DaliException e) {
46547       {
46548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46549       };
46550     } catch (...) {
46551       {
46552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46553       };
46554     }
46555   }
46556
46557 }
46558
46559
46560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46561   void * jresult ;
46562   Dali::ResourceImage *arg1 = 0 ;
46563   Dali::ResourceImage *result = 0 ;
46564
46565   arg1 = (Dali::ResourceImage *)jarg1;
46566   if (!arg1) {
46567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46568     return 0;
46569   }
46570   {
46571     try {
46572       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46573     } catch (std::out_of_range& e) {
46574       {
46575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46576       };
46577     } catch (std::exception& e) {
46578       {
46579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46580       };
46581     } catch (Dali::DaliException e) {
46582       {
46583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46584       };
46585     } catch (...) {
46586       {
46587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46588       };
46589     }
46590   }
46591
46592   jresult = (void *)result;
46593   return jresult;
46594 }
46595
46596
46597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46598   void * jresult ;
46599   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46600   Dali::ResourceImage *arg2 = 0 ;
46601   Dali::ResourceImage *result = 0 ;
46602
46603   arg1 = (Dali::ResourceImage *)jarg1;
46604   arg2 = (Dali::ResourceImage *)jarg2;
46605   if (!arg2) {
46606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46607     return 0;
46608   }
46609   {
46610     try {
46611       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
46612     } catch (std::out_of_range& e) {
46613       {
46614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46615       };
46616     } catch (std::exception& e) {
46617       {
46618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46619       };
46620     } catch (Dali::DaliException e) {
46621       {
46622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46623       };
46624     } catch (...) {
46625       {
46626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46627       };
46628     }
46629   }
46630
46631   jresult = (void *)result;
46632   return jresult;
46633 }
46634
46635
46636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46637   void * jresult ;
46638   std::string *arg1 = 0 ;
46639   bool arg2 ;
46640   Dali::ResourceImage result;
46641
46642   if (!jarg1) {
46643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46644     return 0;
46645   }
46646   std::string arg1_str(jarg1);
46647   arg1 = &arg1_str;
46648   arg2 = jarg2 ? true : false;
46649   {
46650     try {
46651       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46652     } catch (std::out_of_range& e) {
46653       {
46654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46655       };
46656     } catch (std::exception& e) {
46657       {
46658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46659       };
46660     } catch (Dali::DaliException e) {
46661       {
46662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46663       };
46664     } catch (...) {
46665       {
46666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46667       };
46668     }
46669   }
46670
46671   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46672
46673   //argout typemap for const std::string&
46674
46675   return jresult;
46676 }
46677
46678
46679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46680   void * jresult ;
46681   std::string *arg1 = 0 ;
46682   Dali::ResourceImage result;
46683
46684   if (!jarg1) {
46685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46686     return 0;
46687   }
46688   std::string arg1_str(jarg1);
46689   arg1 = &arg1_str;
46690   {
46691     try {
46692       result = Dali::ResourceImage::New((std::string const &)*arg1);
46693     } catch (std::out_of_range& e) {
46694       {
46695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46696       };
46697     } catch (std::exception& e) {
46698       {
46699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46700       };
46701     } catch (Dali::DaliException e) {
46702       {
46703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46704       };
46705     } catch (...) {
46706       {
46707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46708       };
46709     }
46710   }
46711
46712   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46713
46714   //argout typemap for const std::string&
46715
46716   return jresult;
46717 }
46718
46719
46720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46721   void * jresult ;
46722   std::string *arg1 = 0 ;
46723   Dali::ImageDimensions arg2 ;
46724   Dali::FittingMode::Type arg3 ;
46725   Dali::SamplingMode::Type arg4 ;
46726   bool arg5 ;
46727   Dali::ImageDimensions *argp2 ;
46728   Dali::ResourceImage result;
46729
46730   if (!jarg1) {
46731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46732     return 0;
46733   }
46734   std::string arg1_str(jarg1);
46735   arg1 = &arg1_str;
46736   argp2 = (Dali::ImageDimensions *)jarg2;
46737   if (!argp2) {
46738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46739     return 0;
46740   }
46741   arg2 = *argp2;
46742   arg3 = (Dali::FittingMode::Type)jarg3;
46743   arg4 = (Dali::SamplingMode::Type)jarg4;
46744   arg5 = jarg5 ? true : false;
46745   {
46746     try {
46747       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46748     } catch (std::out_of_range& e) {
46749       {
46750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46751       };
46752     } catch (std::exception& e) {
46753       {
46754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46755       };
46756     } catch (Dali::DaliException e) {
46757       {
46758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46759       };
46760     } catch (...) {
46761       {
46762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46763       };
46764     }
46765   }
46766
46767   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46768
46769   //argout typemap for const std::string&
46770
46771   return jresult;
46772 }
46773
46774
46775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46776   void * jresult ;
46777   std::string *arg1 = 0 ;
46778   Dali::ImageDimensions arg2 ;
46779   Dali::FittingMode::Type arg3 ;
46780   Dali::SamplingMode::Type arg4 ;
46781   Dali::ImageDimensions *argp2 ;
46782   Dali::ResourceImage result;
46783
46784   if (!jarg1) {
46785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46786     return 0;
46787   }
46788   std::string arg1_str(jarg1);
46789   arg1 = &arg1_str;
46790   argp2 = (Dali::ImageDimensions *)jarg2;
46791   if (!argp2) {
46792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46793     return 0;
46794   }
46795   arg2 = *argp2;
46796   arg3 = (Dali::FittingMode::Type)jarg3;
46797   arg4 = (Dali::SamplingMode::Type)jarg4;
46798   {
46799     try {
46800       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46801     } catch (std::out_of_range& e) {
46802       {
46803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46804       };
46805     } catch (std::exception& e) {
46806       {
46807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46808       };
46809     } catch (Dali::DaliException e) {
46810       {
46811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46812       };
46813     } catch (...) {
46814       {
46815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46816       };
46817     }
46818   }
46819
46820   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46821
46822   //argout typemap for const std::string&
46823
46824   return jresult;
46825 }
46826
46827
46828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46829   void * jresult ;
46830   std::string *arg1 = 0 ;
46831   Dali::ImageDimensions arg2 ;
46832   Dali::FittingMode::Type arg3 ;
46833   Dali::ImageDimensions *argp2 ;
46834   Dali::ResourceImage result;
46835
46836   if (!jarg1) {
46837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46838     return 0;
46839   }
46840   std::string arg1_str(jarg1);
46841   arg1 = &arg1_str;
46842   argp2 = (Dali::ImageDimensions *)jarg2;
46843   if (!argp2) {
46844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46845     return 0;
46846   }
46847   arg2 = *argp2;
46848   arg3 = (Dali::FittingMode::Type)jarg3;
46849   {
46850     try {
46851       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46852     } catch (std::out_of_range& e) {
46853       {
46854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46855       };
46856     } catch (std::exception& e) {
46857       {
46858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46859       };
46860     } catch (Dali::DaliException e) {
46861       {
46862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46863       };
46864     } catch (...) {
46865       {
46866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46867       };
46868     }
46869   }
46870
46871   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46872
46873   //argout typemap for const std::string&
46874
46875   return jresult;
46876 }
46877
46878
46879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46880   void * jresult ;
46881   std::string *arg1 = 0 ;
46882   Dali::ImageDimensions arg2 ;
46883   Dali::ImageDimensions *argp2 ;
46884   Dali::ResourceImage result;
46885
46886   if (!jarg1) {
46887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46888     return 0;
46889   }
46890   std::string arg1_str(jarg1);
46891   arg1 = &arg1_str;
46892   argp2 = (Dali::ImageDimensions *)jarg2;
46893   if (!argp2) {
46894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46895     return 0;
46896   }
46897   arg2 = *argp2;
46898   {
46899     try {
46900       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46901     } catch (std::out_of_range& e) {
46902       {
46903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (std::exception& e) {
46906       {
46907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (Dali::DaliException e) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46912       };
46913     } catch (...) {
46914       {
46915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46916       };
46917     }
46918   }
46919
46920   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46921
46922   //argout typemap for const std::string&
46923
46924   return jresult;
46925 }
46926
46927
46928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46929   void * jresult ;
46930   Dali::BaseHandle arg1 ;
46931   Dali::BaseHandle *argp1 ;
46932   Dali::ResourceImage result;
46933
46934   argp1 = (Dali::BaseHandle *)jarg1;
46935   if (!argp1) {
46936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46937     return 0;
46938   }
46939   arg1 = *argp1;
46940   {
46941     try {
46942       result = Dali::ResourceImage::DownCast(arg1);
46943     } catch (std::out_of_range& e) {
46944       {
46945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46946       };
46947     } catch (std::exception& e) {
46948       {
46949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46950       };
46951     } catch (Dali::DaliException e) {
46952       {
46953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46954       };
46955     } catch (...) {
46956       {
46957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46958       };
46959     }
46960   }
46961
46962   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46963   return jresult;
46964 }
46965
46966
46967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46968   int jresult ;
46969   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46970   Dali::LoadingState result;
46971
46972   arg1 = (Dali::ResourceImage *)jarg1;
46973   {
46974     try {
46975       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46976     } catch (std::out_of_range& e) {
46977       {
46978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46979       };
46980     } catch (std::exception& e) {
46981       {
46982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46983       };
46984     } catch (Dali::DaliException e) {
46985       {
46986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46987       };
46988     } catch (...) {
46989       {
46990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46991       };
46992     }
46993   }
46994
46995   jresult = (int)result;
46996   return jresult;
46997 }
46998
46999
47000 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
47001   char * jresult ;
47002   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47003   std::string result;
47004
47005   arg1 = (Dali::ResourceImage *)jarg1;
47006   {
47007     try {
47008       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47009     } catch (std::out_of_range& e) {
47010       {
47011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47012       };
47013     } catch (std::exception& e) {
47014       {
47015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47016       };
47017     } catch (Dali::DaliException e) {
47018       {
47019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47020       };
47021     } catch (...) {
47022       {
47023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47024       };
47025     }
47026   }
47027
47028   jresult = SWIG_csharp_string_callback((&result)->c_str());
47029   return jresult;
47030 }
47031
47032
47033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47034   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47035
47036   arg1 = (Dali::ResourceImage *)jarg1;
47037   {
47038     try {
47039       (arg1)->Reload();
47040     } catch (std::out_of_range& e) {
47041       {
47042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47043       };
47044     } catch (std::exception& e) {
47045       {
47046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47047       };
47048     } catch (Dali::DaliException e) {
47049       {
47050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47051       };
47052     } catch (...) {
47053       {
47054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47055       };
47056     }
47057   }
47058
47059 }
47060
47061
47062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47063   void * jresult ;
47064   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47065   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47066
47067   arg1 = (Dali::ResourceImage *)jarg1;
47068   {
47069     try {
47070       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47071     } catch (std::out_of_range& e) {
47072       {
47073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (std::exception& e) {
47076       {
47077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47078       };
47079     } catch (Dali::DaliException e) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47082       };
47083     } catch (...) {
47084       {
47085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47086       };
47087     }
47088   }
47089
47090   jresult = (void *)result;
47091   return jresult;
47092 }
47093
47094
47095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47096   void * jresult ;
47097   Dali::FrameBufferImage *result = 0 ;
47098
47099   {
47100     try {
47101       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47102     } catch (std::out_of_range& e) {
47103       {
47104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47105       };
47106     } catch (std::exception& e) {
47107       {
47108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (Dali::DaliException e) {
47111       {
47112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47113       };
47114     } catch (...) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47117       };
47118     }
47119   }
47120
47121   jresult = (void *)result;
47122   return jresult;
47123 }
47124
47125
47126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47127   void * jresult ;
47128   unsigned int arg1 ;
47129   unsigned int arg2 ;
47130   Dali::Pixel::Format arg3 ;
47131   Dali::RenderBuffer::Format arg4 ;
47132   Dali::FrameBufferImage result;
47133
47134   arg1 = (unsigned int)jarg1;
47135   arg2 = (unsigned int)jarg2;
47136   arg3 = (Dali::Pixel::Format)jarg3;
47137   arg4 = (Dali::RenderBuffer::Format)jarg4;
47138   {
47139     try {
47140       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
47141     } catch (std::out_of_range& e) {
47142       {
47143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47144       };
47145     } catch (std::exception& e) {
47146       {
47147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (Dali::DaliException e) {
47150       {
47151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47152       };
47153     } catch (...) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47156       };
47157     }
47158   }
47159
47160   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47161   return jresult;
47162 }
47163
47164
47165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47166   void * jresult ;
47167   unsigned int arg1 ;
47168   unsigned int arg2 ;
47169   Dali::Pixel::Format arg3 ;
47170   Dali::FrameBufferImage result;
47171
47172   arg1 = (unsigned int)jarg1;
47173   arg2 = (unsigned int)jarg2;
47174   arg3 = (Dali::Pixel::Format)jarg3;
47175   {
47176     try {
47177       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47178     } catch (std::out_of_range& e) {
47179       {
47180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47181       };
47182     } catch (std::exception& e) {
47183       {
47184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47185       };
47186     } catch (Dali::DaliException e) {
47187       {
47188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47189       };
47190     } catch (...) {
47191       {
47192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47193       };
47194     }
47195   }
47196
47197   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47198   return jresult;
47199 }
47200
47201
47202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47203   void * jresult ;
47204   unsigned int arg1 ;
47205   unsigned int arg2 ;
47206   Dali::FrameBufferImage result;
47207
47208   arg1 = (unsigned int)jarg1;
47209   arg2 = (unsigned int)jarg2;
47210   {
47211     try {
47212       result = Dali::FrameBufferImage::New(arg1,arg2);
47213     } catch (std::out_of_range& e) {
47214       {
47215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (std::exception& e) {
47218       {
47219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47220       };
47221     } catch (Dali::DaliException e) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47224       };
47225     } catch (...) {
47226       {
47227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47228       };
47229     }
47230   }
47231
47232   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47233   return jresult;
47234 }
47235
47236
47237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47238   void * jresult ;
47239   unsigned int arg1 ;
47240   Dali::FrameBufferImage result;
47241
47242   arg1 = (unsigned int)jarg1;
47243   {
47244     try {
47245       result = Dali::FrameBufferImage::New(arg1);
47246     } catch (std::out_of_range& e) {
47247       {
47248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47249       };
47250     } catch (std::exception& e) {
47251       {
47252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47253       };
47254     } catch (Dali::DaliException e) {
47255       {
47256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47257       };
47258     } catch (...) {
47259       {
47260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47261       };
47262     }
47263   }
47264
47265   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47266   return jresult;
47267 }
47268
47269
47270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47271   void * jresult ;
47272   Dali::FrameBufferImage result;
47273
47274   {
47275     try {
47276       result = Dali::FrameBufferImage::New();
47277     } catch (std::out_of_range& e) {
47278       {
47279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47280       };
47281     } catch (std::exception& e) {
47282       {
47283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47284       };
47285     } catch (Dali::DaliException e) {
47286       {
47287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47288       };
47289     } catch (...) {
47290       {
47291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47292       };
47293     }
47294   }
47295
47296   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47297   return jresult;
47298 }
47299
47300
47301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47302   void * jresult ;
47303   Dali::NativeImageInterface *arg1 = 0 ;
47304   Dali::FrameBufferImage result;
47305
47306   arg1 = (Dali::NativeImageInterface *)jarg1;
47307   if (!arg1) {
47308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47309     return 0;
47310   }
47311   {
47312     try {
47313       result = Dali::FrameBufferImage::New(*arg1);
47314     } catch (std::out_of_range& e) {
47315       {
47316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47317       };
47318     } catch (std::exception& e) {
47319       {
47320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (Dali::DaliException e) {
47323       {
47324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47325       };
47326     } catch (...) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47329       };
47330     }
47331   }
47332
47333   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47334   return jresult;
47335 }
47336
47337
47338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47339   void * jresult ;
47340   Dali::BaseHandle arg1 ;
47341   Dali::BaseHandle *argp1 ;
47342   Dali::FrameBufferImage result;
47343
47344   argp1 = (Dali::BaseHandle *)jarg1;
47345   if (!argp1) {
47346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47347     return 0;
47348   }
47349   arg1 = *argp1;
47350   {
47351     try {
47352       result = Dali::FrameBufferImage::DownCast(arg1);
47353     } catch (std::out_of_range& e) {
47354       {
47355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47356       };
47357     } catch (std::exception& e) {
47358       {
47359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47360       };
47361     } catch (Dali::DaliException e) {
47362       {
47363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47364       };
47365     } catch (...) {
47366       {
47367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47368       };
47369     }
47370   }
47371
47372   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47373   return jresult;
47374 }
47375
47376
47377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
47378   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47379
47380   arg1 = (Dali::FrameBufferImage *)jarg1;
47381   {
47382     try {
47383       delete arg1;
47384     } catch (std::out_of_range& e) {
47385       {
47386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47387       };
47388     } catch (std::exception& e) {
47389       {
47390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47391       };
47392     } catch (Dali::DaliException e) {
47393       {
47394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47395       };
47396     } catch (...) {
47397       {
47398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47399       };
47400     }
47401   }
47402
47403 }
47404
47405
47406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47407   void * jresult ;
47408   Dali::FrameBufferImage *arg1 = 0 ;
47409   Dali::FrameBufferImage *result = 0 ;
47410
47411   arg1 = (Dali::FrameBufferImage *)jarg1;
47412   if (!arg1) {
47413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47414     return 0;
47415   }
47416   {
47417     try {
47418       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47419     } catch (std::out_of_range& e) {
47420       {
47421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47422       };
47423     } catch (std::exception& e) {
47424       {
47425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47426       };
47427     } catch (Dali::DaliException e) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47430       };
47431     } catch (...) {
47432       {
47433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47434       };
47435     }
47436   }
47437
47438   jresult = (void *)result;
47439   return jresult;
47440 }
47441
47442
47443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47444   void * jresult ;
47445   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47446   Dali::FrameBufferImage *arg2 = 0 ;
47447   Dali::FrameBufferImage *result = 0 ;
47448
47449   arg1 = (Dali::FrameBufferImage *)jarg1;
47450   arg2 = (Dali::FrameBufferImage *)jarg2;
47451   if (!arg2) {
47452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47453     return 0;
47454   }
47455   {
47456     try {
47457       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
47458     } catch (std::out_of_range& e) {
47459       {
47460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47461       };
47462     } catch (std::exception& e) {
47463       {
47464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47465       };
47466     } catch (Dali::DaliException e) {
47467       {
47468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47469       };
47470     } catch (...) {
47471       {
47472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47473       };
47474     }
47475   }
47476
47477   jresult = (void *)result;
47478   return jresult;
47479 }
47480
47481
47482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_0() {
47483   void * jresult ;
47484   Dali::NinePatchImage *result = 0 ;
47485
47486   {
47487     try {
47488       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47489     } catch (std::out_of_range& e) {
47490       {
47491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47492       };
47493     } catch (std::exception& e) {
47494       {
47495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47496       };
47497     } catch (Dali::DaliException e) {
47498       {
47499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47500       };
47501     } catch (...) {
47502       {
47503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47504       };
47505     }
47506   }
47507
47508   jresult = (void *)result;
47509   return jresult;
47510 }
47511
47512
47513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47514   void * jresult ;
47515   std::string *arg1 = 0 ;
47516   Dali::NinePatchImage result;
47517
47518   if (!jarg1) {
47519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47520     return 0;
47521   }
47522   std::string arg1_str(jarg1);
47523   arg1 = &arg1_str;
47524   {
47525     try {
47526       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47527     } catch (std::out_of_range& e) {
47528       {
47529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47530       };
47531     } catch (std::exception& e) {
47532       {
47533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47534       };
47535     } catch (Dali::DaliException e) {
47536       {
47537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47538       };
47539     } catch (...) {
47540       {
47541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47542       };
47543     }
47544   }
47545
47546   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47547
47548   //argout typemap for const std::string&
47549
47550   return jresult;
47551 }
47552
47553
47554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47555   void * jresult ;
47556   Dali::BaseHandle arg1 ;
47557   Dali::BaseHandle *argp1 ;
47558   Dali::NinePatchImage result;
47559
47560   argp1 = (Dali::BaseHandle *)jarg1;
47561   if (!argp1) {
47562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47563     return 0;
47564   }
47565   arg1 = *argp1;
47566   {
47567     try {
47568       result = Dali::NinePatchImage::DownCast(arg1);
47569     } catch (std::out_of_range& e) {
47570       {
47571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47572       };
47573     } catch (std::exception& e) {
47574       {
47575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47576       };
47577     } catch (Dali::DaliException e) {
47578       {
47579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47580       };
47581     } catch (...) {
47582       {
47583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47584       };
47585     }
47586   }
47587
47588   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47589   return jresult;
47590 }
47591
47592
47593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47594   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47595
47596   arg1 = (Dali::NinePatchImage *)jarg1;
47597   {
47598     try {
47599       delete arg1;
47600     } catch (std::out_of_range& e) {
47601       {
47602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47603       };
47604     } catch (std::exception& e) {
47605       {
47606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47607       };
47608     } catch (Dali::DaliException e) {
47609       {
47610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47611       };
47612     } catch (...) {
47613       {
47614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47615       };
47616     }
47617   }
47618
47619 }
47620
47621
47622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47623   void * jresult ;
47624   Dali::NinePatchImage *arg1 = 0 ;
47625   Dali::NinePatchImage *result = 0 ;
47626
47627   arg1 = (Dali::NinePatchImage *)jarg1;
47628   if (!arg1) {
47629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47630     return 0;
47631   }
47632   {
47633     try {
47634       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47635     } catch (std::out_of_range& e) {
47636       {
47637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47638       };
47639     } catch (std::exception& e) {
47640       {
47641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47642       };
47643     } catch (Dali::DaliException e) {
47644       {
47645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47646       };
47647     } catch (...) {
47648       {
47649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47650       };
47651     }
47652   }
47653
47654   jresult = (void *)result;
47655   return jresult;
47656 }
47657
47658
47659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47660   void * jresult ;
47661   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47662   Dali::NinePatchImage *arg2 = 0 ;
47663   Dali::NinePatchImage *result = 0 ;
47664
47665   arg1 = (Dali::NinePatchImage *)jarg1;
47666   arg2 = (Dali::NinePatchImage *)jarg2;
47667   if (!arg2) {
47668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47669     return 0;
47670   }
47671   {
47672     try {
47673       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
47674     } catch (std::out_of_range& e) {
47675       {
47676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47677       };
47678     } catch (std::exception& e) {
47679       {
47680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47681       };
47682     } catch (Dali::DaliException e) {
47683       {
47684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47685       };
47686     } catch (...) {
47687       {
47688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47689       };
47690     }
47691   }
47692
47693   jresult = (void *)result;
47694   return jresult;
47695 }
47696
47697
47698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchBorders(void * jarg1) {
47699   void * jresult ;
47700   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47701   Dali::Vector4 result;
47702
47703   arg1 = (Dali::NinePatchImage *)jarg1;
47704   {
47705     try {
47706       result = (arg1)->GetStretchBorders();
47707     } catch (std::out_of_range& e) {
47708       {
47709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (std::exception& e) {
47712       {
47713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (Dali::DaliException e) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47718       };
47719     } catch (...) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47722       };
47723     }
47724   }
47725
47726   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47727   return jresult;
47728 }
47729
47730
47731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47732   void * jresult ;
47733   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47734   Dali::NinePatchImage::StretchRanges *result = 0 ;
47735
47736   arg1 = (Dali::NinePatchImage *)jarg1;
47737   {
47738     try {
47739       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47740     } catch (std::out_of_range& e) {
47741       {
47742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (std::exception& e) {
47745       {
47746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (Dali::DaliException e) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47751       };
47752     } catch (...) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47755       };
47756     }
47757   }
47758
47759   jresult = (void *)result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47765   void * jresult ;
47766   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47767   Dali::NinePatchImage::StretchRanges *result = 0 ;
47768
47769   arg1 = (Dali::NinePatchImage *)jarg1;
47770   {
47771     try {
47772       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47773     } catch (std::out_of_range& e) {
47774       {
47775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (std::exception& e) {
47778       {
47779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (Dali::DaliException e) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47784       };
47785     } catch (...) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47788       };
47789     }
47790   }
47791
47792   jresult = (void *)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47798   void * jresult ;
47799   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47800   Dali::Rect< int > result;
47801
47802   arg1 = (Dali::NinePatchImage *)jarg1;
47803   {
47804     try {
47805       result = (arg1)->GetChildRectangle();
47806     } catch (std::out_of_range& e) {
47807       {
47808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47809       };
47810     } catch (std::exception& e) {
47811       {
47812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47813       };
47814     } catch (Dali::DaliException e) {
47815       {
47816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47817       };
47818     } catch (...) {
47819       {
47820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47821       };
47822     }
47823   }
47824
47825   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47826   return jresult;
47827 }
47828
47829
47830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47831   void * jresult ;
47832   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47833   Dali::BufferImage result;
47834
47835   arg1 = (Dali::NinePatchImage *)jarg1;
47836   {
47837     try {
47838       result = (arg1)->CreateCroppedBufferImage();
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47846       };
47847     } catch (Dali::DaliException e) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47854       };
47855     }
47856   }
47857
47858   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47859   return jresult;
47860 }
47861
47862
47863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47864   unsigned int jresult ;
47865   std::string *arg1 = 0 ;
47866   bool result;
47867
47868   if (!jarg1) {
47869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47870     return 0;
47871   }
47872   std::string arg1_str(jarg1);
47873   arg1 = &arg1_str;
47874   {
47875     try {
47876       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47877     } catch (std::out_of_range& e) {
47878       {
47879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (std::exception& e) {
47882       {
47883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47884       };
47885     } catch (Dali::DaliException e) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47888       };
47889     } catch (...) {
47890       {
47891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47892       };
47893     }
47894   }
47895
47896   jresult = result;
47897
47898   //argout typemap for const std::string&
47899
47900   return jresult;
47901 }
47902
47903
47904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47905   int jresult ;
47906   int result;
47907
47908   result = (int)Dali::CameraActor::Property::TYPE;
47909   jresult = (int)result;
47910   return jresult;
47911 }
47912
47913
47914 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47915   int jresult ;
47916   int result;
47917
47918   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47919   jresult = (int)result;
47920   return jresult;
47921 }
47922
47923
47924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47925   int jresult ;
47926   int result;
47927
47928   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47929   jresult = (int)result;
47930   return jresult;
47931 }
47932
47933
47934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47935   int jresult ;
47936   int result;
47937
47938   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47939   jresult = (int)result;
47940   return jresult;
47941 }
47942
47943
47944 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47945   int jresult ;
47946   int result;
47947
47948   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47949   jresult = (int)result;
47950   return jresult;
47951 }
47952
47953
47954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47955   int jresult ;
47956   int result;
47957
47958   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47959   jresult = (int)result;
47960   return jresult;
47961 }
47962
47963
47964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47965   int jresult ;
47966   int result;
47967
47968   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47969   jresult = (int)result;
47970   return jresult;
47971 }
47972
47973
47974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47975   int jresult ;
47976   int result;
47977
47978   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47979   jresult = (int)result;
47980   return jresult;
47981 }
47982
47983
47984 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47985   int jresult ;
47986   int result;
47987
47988   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47989   jresult = (int)result;
47990   return jresult;
47991 }
47992
47993
47994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47995   int jresult ;
47996   int result;
47997
47998   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47999   jresult = (int)result;
48000   return jresult;
48001 }
48002
48003
48004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48005   int jresult ;
48006   int result;
48007
48008   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48009   jresult = (int)result;
48010   return jresult;
48011 }
48012
48013
48014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48015   int jresult ;
48016   int result;
48017
48018   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48019   jresult = (int)result;
48020   return jresult;
48021 }
48022
48023
48024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48025   int jresult ;
48026   int result;
48027
48028   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48029   jresult = (int)result;
48030   return jresult;
48031 }
48032
48033
48034 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48035   int jresult ;
48036   int result;
48037
48038   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48039   jresult = (int)result;
48040   return jresult;
48041 }
48042
48043
48044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48045   void * jresult ;
48046   Dali::CameraActor::Property *result = 0 ;
48047
48048   {
48049     try {
48050       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48051     } catch (std::out_of_range& e) {
48052       {
48053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48054       };
48055     } catch (std::exception& e) {
48056       {
48057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48058       };
48059     } catch (Dali::DaliException e) {
48060       {
48061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48062       };
48063     } catch (...) {
48064       {
48065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48066       };
48067     }
48068   }
48069
48070   jresult = (void *)result;
48071   return jresult;
48072 }
48073
48074
48075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48076   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48077
48078   arg1 = (Dali::CameraActor::Property *)jarg1;
48079   {
48080     try {
48081       delete arg1;
48082     } catch (std::out_of_range& e) {
48083       {
48084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48085       };
48086     } catch (std::exception& e) {
48087       {
48088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48089       };
48090     } catch (Dali::DaliException e) {
48091       {
48092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48093       };
48094     } catch (...) {
48095       {
48096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48097       };
48098     }
48099   }
48100
48101 }
48102
48103
48104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48105   void * jresult ;
48106   Dali::CameraActor *result = 0 ;
48107
48108   {
48109     try {
48110       result = (Dali::CameraActor *)new Dali::CameraActor();
48111     } catch (std::out_of_range& e) {
48112       {
48113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48114       };
48115     } catch (std::exception& e) {
48116       {
48117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48118       };
48119     } catch (Dali::DaliException e) {
48120       {
48121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48122       };
48123     } catch (...) {
48124       {
48125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48126       };
48127     }
48128   }
48129
48130   jresult = (void *)result;
48131   return jresult;
48132 }
48133
48134
48135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48136   void * jresult ;
48137   Dali::CameraActor result;
48138
48139   {
48140     try {
48141       result = Dali::CameraActor::New();
48142     } catch (std::out_of_range& e) {
48143       {
48144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48145       };
48146     } catch (std::exception& e) {
48147       {
48148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48149       };
48150     } catch (Dali::DaliException e) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48153       };
48154     } catch (...) {
48155       {
48156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48157       };
48158     }
48159   }
48160
48161   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48162   return jresult;
48163 }
48164
48165
48166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48167   void * jresult ;
48168   Dali::Size *arg1 = 0 ;
48169   Dali::CameraActor result;
48170
48171   arg1 = (Dali::Size *)jarg1;
48172   if (!arg1) {
48173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48174     return 0;
48175   }
48176   {
48177     try {
48178       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48179     } catch (std::out_of_range& e) {
48180       {
48181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48182       };
48183     } catch (std::exception& e) {
48184       {
48185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48186       };
48187     } catch (Dali::DaliException e) {
48188       {
48189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48190       };
48191     } catch (...) {
48192       {
48193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48194       };
48195     }
48196   }
48197
48198   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48199   return jresult;
48200 }
48201
48202
48203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48204   void * jresult ;
48205   Dali::BaseHandle arg1 ;
48206   Dali::BaseHandle *argp1 ;
48207   Dali::CameraActor result;
48208
48209   argp1 = (Dali::BaseHandle *)jarg1;
48210   if (!argp1) {
48211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48212     return 0;
48213   }
48214   arg1 = *argp1;
48215   {
48216     try {
48217       result = Dali::CameraActor::DownCast(arg1);
48218     } catch (std::out_of_range& e) {
48219       {
48220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48221       };
48222     } catch (std::exception& e) {
48223       {
48224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48225       };
48226     } catch (Dali::DaliException e) {
48227       {
48228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48229       };
48230     } catch (...) {
48231       {
48232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48233       };
48234     }
48235   }
48236
48237   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48238   return jresult;
48239 }
48240
48241
48242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
48243   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48244
48245   arg1 = (Dali::CameraActor *)jarg1;
48246   {
48247     try {
48248       delete arg1;
48249     } catch (std::out_of_range& e) {
48250       {
48251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48252       };
48253     } catch (std::exception& e) {
48254       {
48255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48256       };
48257     } catch (Dali::DaliException e) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48260       };
48261     } catch (...) {
48262       {
48263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48264       };
48265     }
48266   }
48267
48268 }
48269
48270
48271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48272   void * jresult ;
48273   Dali::CameraActor *arg1 = 0 ;
48274   Dali::CameraActor *result = 0 ;
48275
48276   arg1 = (Dali::CameraActor *)jarg1;
48277   if (!arg1) {
48278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48279     return 0;
48280   }
48281   {
48282     try {
48283       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48284     } catch (std::out_of_range& e) {
48285       {
48286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48287       };
48288     } catch (std::exception& e) {
48289       {
48290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48291       };
48292     } catch (Dali::DaliException e) {
48293       {
48294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48295       };
48296     } catch (...) {
48297       {
48298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48299       };
48300     }
48301   }
48302
48303   jresult = (void *)result;
48304   return jresult;
48305 }
48306
48307
48308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48309   void * jresult ;
48310   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48311   Dali::CameraActor *arg2 = 0 ;
48312   Dali::CameraActor *result = 0 ;
48313
48314   arg1 = (Dali::CameraActor *)jarg1;
48315   arg2 = (Dali::CameraActor *)jarg2;
48316   if (!arg2) {
48317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48318     return 0;
48319   }
48320   {
48321     try {
48322       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
48323     } catch (std::out_of_range& e) {
48324       {
48325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48326       };
48327     } catch (std::exception& e) {
48328       {
48329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48330       };
48331     } catch (Dali::DaliException e) {
48332       {
48333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48334       };
48335     } catch (...) {
48336       {
48337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48338       };
48339     }
48340   }
48341
48342   jresult = (void *)result;
48343   return jresult;
48344 }
48345
48346
48347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
48348   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48349   Dali::Camera::Type arg2 ;
48350
48351   arg1 = (Dali::CameraActor *)jarg1;
48352   arg2 = (Dali::Camera::Type)jarg2;
48353   {
48354     try {
48355       (arg1)->SetType(arg2);
48356     } catch (std::out_of_range& e) {
48357       {
48358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48359       };
48360     } catch (std::exception& e) {
48361       {
48362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48363       };
48364     } catch (Dali::DaliException e) {
48365       {
48366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48367       };
48368     } catch (...) {
48369       {
48370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48371       };
48372     }
48373   }
48374
48375 }
48376
48377
48378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48379   int jresult ;
48380   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48381   Dali::Camera::Type result;
48382
48383   arg1 = (Dali::CameraActor *)jarg1;
48384   {
48385     try {
48386       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48387     } catch (std::out_of_range& e) {
48388       {
48389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (std::exception& e) {
48392       {
48393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48394       };
48395     } catch (Dali::DaliException e) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48398       };
48399     } catch (...) {
48400       {
48401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48402       };
48403     }
48404   }
48405
48406   jresult = (int)result;
48407   return jresult;
48408 }
48409
48410
48411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48412   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48413   Dali::Camera::ProjectionMode arg2 ;
48414
48415   arg1 = (Dali::CameraActor *)jarg1;
48416   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48417   {
48418     try {
48419       (arg1)->SetProjectionMode(arg2);
48420     } catch (std::out_of_range& e) {
48421       {
48422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48423       };
48424     } catch (std::exception& e) {
48425       {
48426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48427       };
48428     } catch (Dali::DaliException e) {
48429       {
48430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48431       };
48432     } catch (...) {
48433       {
48434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48435       };
48436     }
48437   }
48438
48439 }
48440
48441
48442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48443   int jresult ;
48444   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48445   Dali::Camera::ProjectionMode result;
48446
48447   arg1 = (Dali::CameraActor *)jarg1;
48448   {
48449     try {
48450       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48458       };
48459     } catch (Dali::DaliException e) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48462       };
48463     } catch (...) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48466       };
48467     }
48468   }
48469
48470   jresult = (int)result;
48471   return jresult;
48472 }
48473
48474
48475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48476   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48477   float arg2 ;
48478
48479   arg1 = (Dali::CameraActor *)jarg1;
48480   arg2 = (float)jarg2;
48481   {
48482     try {
48483       (arg1)->SetFieldOfView(arg2);
48484     } catch (std::out_of_range& e) {
48485       {
48486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48487       };
48488     } catch (std::exception& e) {
48489       {
48490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48491       };
48492     } catch (Dali::DaliException e) {
48493       {
48494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48495       };
48496     } catch (...) {
48497       {
48498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48499       };
48500     }
48501   }
48502
48503 }
48504
48505
48506 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48507   float jresult ;
48508   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48509   float result;
48510
48511   arg1 = (Dali::CameraActor *)jarg1;
48512   {
48513     try {
48514       result = (float)(arg1)->GetFieldOfView();
48515     } catch (std::out_of_range& e) {
48516       {
48517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48518       };
48519     } catch (std::exception& e) {
48520       {
48521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48522       };
48523     } catch (Dali::DaliException e) {
48524       {
48525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48526       };
48527     } catch (...) {
48528       {
48529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48530       };
48531     }
48532   }
48533
48534   jresult = result;
48535   return jresult;
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48540   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48541   float arg2 ;
48542
48543   arg1 = (Dali::CameraActor *)jarg1;
48544   arg2 = (float)jarg2;
48545   {
48546     try {
48547       (arg1)->SetAspectRatio(arg2);
48548     } catch (std::out_of_range& e) {
48549       {
48550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (std::exception& e) {
48553       {
48554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (Dali::DaliException e) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566
48567 }
48568
48569
48570 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48571   float jresult ;
48572   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48573   float result;
48574
48575   arg1 = (Dali::CameraActor *)jarg1;
48576   {
48577     try {
48578       result = (float)(arg1)->GetAspectRatio();
48579     } catch (std::out_of_range& e) {
48580       {
48581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48582       };
48583     } catch (std::exception& e) {
48584       {
48585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48586       };
48587     } catch (Dali::DaliException e) {
48588       {
48589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48590       };
48591     } catch (...) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48594       };
48595     }
48596   }
48597
48598   jresult = result;
48599   return jresult;
48600 }
48601
48602
48603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48604   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48605   float arg2 ;
48606
48607   arg1 = (Dali::CameraActor *)jarg1;
48608   arg2 = (float)jarg2;
48609   {
48610     try {
48611       (arg1)->SetNearClippingPlane(arg2);
48612     } catch (std::out_of_range& e) {
48613       {
48614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48615       };
48616     } catch (std::exception& e) {
48617       {
48618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48619       };
48620     } catch (Dali::DaliException e) {
48621       {
48622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48623       };
48624     } catch (...) {
48625       {
48626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48627       };
48628     }
48629   }
48630
48631 }
48632
48633
48634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48635   float jresult ;
48636   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48637   float result;
48638
48639   arg1 = (Dali::CameraActor *)jarg1;
48640   {
48641     try {
48642       result = (float)(arg1)->GetNearClippingPlane();
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (Dali::DaliException e) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48654       };
48655     } catch (...) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48658       };
48659     }
48660   }
48661
48662   jresult = result;
48663   return jresult;
48664 }
48665
48666
48667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48668   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48669   float arg2 ;
48670
48671   arg1 = (Dali::CameraActor *)jarg1;
48672   arg2 = (float)jarg2;
48673   {
48674     try {
48675       (arg1)->SetFarClippingPlane(arg2);
48676     } catch (std::out_of_range& e) {
48677       {
48678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48679       };
48680     } catch (std::exception& e) {
48681       {
48682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48683       };
48684     } catch (Dali::DaliException e) {
48685       {
48686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48687       };
48688     } catch (...) {
48689       {
48690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48691       };
48692     }
48693   }
48694
48695 }
48696
48697
48698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48699   float jresult ;
48700   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48701   float result;
48702
48703   arg1 = (Dali::CameraActor *)jarg1;
48704   {
48705     try {
48706       result = (float)(arg1)->GetFarClippingPlane();
48707     } catch (std::out_of_range& e) {
48708       {
48709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48710       };
48711     } catch (std::exception& e) {
48712       {
48713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48714       };
48715     } catch (Dali::DaliException e) {
48716       {
48717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48718       };
48719     } catch (...) {
48720       {
48721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48722       };
48723     }
48724   }
48725
48726   jresult = result;
48727   return jresult;
48728 }
48729
48730
48731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48732   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48733   Dali::Vector3 *arg2 = 0 ;
48734
48735   arg1 = (Dali::CameraActor *)jarg1;
48736   arg2 = (Dali::Vector3 *)jarg2;
48737   if (!arg2) {
48738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48739     return ;
48740   }
48741   {
48742     try {
48743       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48744     } catch (std::out_of_range& e) {
48745       {
48746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48747       };
48748     } catch (std::exception& e) {
48749       {
48750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48751       };
48752     } catch (Dali::DaliException e) {
48753       {
48754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48755       };
48756     } catch (...) {
48757       {
48758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48759       };
48760     }
48761   }
48762
48763 }
48764
48765
48766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48767   void * jresult ;
48768   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48769   Dali::Vector3 result;
48770
48771   arg1 = (Dali::CameraActor *)jarg1;
48772   {
48773     try {
48774       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48775     } catch (std::out_of_range& e) {
48776       {
48777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48778       };
48779     } catch (std::exception& e) {
48780       {
48781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48782       };
48783     } catch (Dali::DaliException e) {
48784       {
48785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48786       };
48787     } catch (...) {
48788       {
48789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48790       };
48791     }
48792   }
48793
48794   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48795   return jresult;
48796 }
48797
48798
48799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48800   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48801   bool arg2 ;
48802
48803   arg1 = (Dali::CameraActor *)jarg1;
48804   arg2 = jarg2 ? true : false;
48805   {
48806     try {
48807       (arg1)->SetInvertYAxis(arg2);
48808     } catch (std::out_of_range& e) {
48809       {
48810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48811       };
48812     } catch (std::exception& e) {
48813       {
48814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48815       };
48816     } catch (Dali::DaliException e) {
48817       {
48818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48819       };
48820     } catch (...) {
48821       {
48822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48823       };
48824     }
48825   }
48826
48827 }
48828
48829
48830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48831   unsigned int jresult ;
48832   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48833   bool result;
48834
48835   arg1 = (Dali::CameraActor *)jarg1;
48836   {
48837     try {
48838       result = (bool)(arg1)->GetInvertYAxis();
48839     } catch (std::out_of_range& e) {
48840       {
48841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48842       };
48843     } catch (std::exception& e) {
48844       {
48845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48846       };
48847     } catch (Dali::DaliException e) {
48848       {
48849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48850       };
48851     } catch (...) {
48852       {
48853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48854       };
48855     }
48856   }
48857
48858   jresult = result;
48859   return jresult;
48860 }
48861
48862
48863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48864   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48865   Dali::Size *arg2 = 0 ;
48866
48867   arg1 = (Dali::CameraActor *)jarg1;
48868   arg2 = (Dali::Size *)jarg2;
48869   if (!arg2) {
48870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48871     return ;
48872   }
48873   {
48874     try {
48875       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48876     } catch (std::out_of_range& e) {
48877       {
48878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48879       };
48880     } catch (std::exception& e) {
48881       {
48882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48883       };
48884     } catch (Dali::DaliException e) {
48885       {
48886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48887       };
48888     } catch (...) {
48889       {
48890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48891       };
48892     }
48893   }
48894
48895 }
48896
48897
48898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48899   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48900   Dali::Size *arg2 = 0 ;
48901
48902   arg1 = (Dali::CameraActor *)jarg1;
48903   arg2 = (Dali::Size *)jarg2;
48904   if (!arg2) {
48905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48906     return ;
48907   }
48908   {
48909     try {
48910       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48911     } catch (std::out_of_range& e) {
48912       {
48913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48914       };
48915     } catch (std::exception& e) {
48916       {
48917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48918       };
48919     } catch (Dali::DaliException e) {
48920       {
48921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48922       };
48923     } catch (...) {
48924       {
48925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48926       };
48927     }
48928   }
48929
48930 }
48931
48932
48933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48934   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48935   float arg2 ;
48936   float arg3 ;
48937   float arg4 ;
48938   float arg5 ;
48939   float arg6 ;
48940   float arg7 ;
48941
48942   arg1 = (Dali::CameraActor *)jarg1;
48943   arg2 = (float)jarg2;
48944   arg3 = (float)jarg3;
48945   arg4 = (float)jarg4;
48946   arg5 = (float)jarg5;
48947   arg6 = (float)jarg6;
48948   arg7 = (float)jarg7;
48949   {
48950     try {
48951       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48952     } catch (std::out_of_range& e) {
48953       {
48954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48955       };
48956     } catch (std::exception& e) {
48957       {
48958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48959       };
48960     } catch (Dali::DaliException e) {
48961       {
48962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48963       };
48964     } catch (...) {
48965       {
48966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48967       };
48968     }
48969   }
48970
48971 }
48972
48973
48974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48975   void * jresult ;
48976   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48977
48978   {
48979     try {
48980       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48981     } catch (std::out_of_range& e) {
48982       {
48983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48984       };
48985     } catch (std::exception& e) {
48986       {
48987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48988       };
48989     } catch (Dali::DaliException e) {
48990       {
48991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48992       };
48993     } catch (...) {
48994       {
48995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48996       };
48997     }
48998   }
48999
49000   jresult = (void *)result;
49001   return jresult;
49002 }
49003
49004
49005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49006   void * jresult ;
49007   std::string arg1 ;
49008   Dali::Property::Value arg2 ;
49009   Dali::Property::Value *argp2 ;
49010   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49011
49012   if (!jarg1) {
49013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49014     return 0;
49015   }
49016   (&arg1)->assign(jarg1);
49017   argp2 = (Dali::Property::Value *)jarg2;
49018   if (!argp2) {
49019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49020     return 0;
49021   }
49022   arg2 = *argp2;
49023   {
49024     try {
49025       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49026     } catch (std::out_of_range& e) {
49027       {
49028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49029       };
49030     } catch (std::exception& e) {
49031       {
49032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49033       };
49034     } catch (Dali::DaliException e) {
49035       {
49036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49037       };
49038     } catch (...) {
49039       {
49040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49041       };
49042     }
49043   }
49044
49045   jresult = (void *)result;
49046   return jresult;
49047 }
49048
49049
49050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49051   void * jresult ;
49052   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49053   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49054
49055   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49056   if (!arg1) {
49057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49058     return 0;
49059   }
49060   {
49061     try {
49062       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);
49063     } catch (std::out_of_range& e) {
49064       {
49065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (std::exception& e) {
49068       {
49069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (Dali::DaliException e) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49074       };
49075     } catch (...) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49078       };
49079     }
49080   }
49081
49082   jresult = (void *)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49088   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49089   std::string *arg2 = 0 ;
49090
49091   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49092   if (!jarg2) {
49093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49094     return ;
49095   }
49096   std::string arg2_str(jarg2);
49097   arg2 = &arg2_str;
49098   if (arg1) (arg1)->first = *arg2;
49099
49100   //argout typemap for const std::string&
49101
49102 }
49103
49104
49105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49106   char * jresult ;
49107   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49108   std::string *result = 0 ;
49109
49110   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49111   result = (std::string *) & ((arg1)->first);
49112   jresult = SWIG_csharp_string_callback(result->c_str());
49113   return jresult;
49114 }
49115
49116
49117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49118   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49119   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49120
49121   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49122   arg2 = (Dali::Property::Value *)jarg2;
49123   if (arg1) (arg1)->second = *arg2;
49124 }
49125
49126
49127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49128   void * jresult ;
49129   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49130   Dali::Property::Value *result = 0 ;
49131
49132   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49133   result = (Dali::Property::Value *)& ((arg1)->second);
49134   jresult = (void *)result;
49135   return jresult;
49136 }
49137
49138
49139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49140   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49141
49142   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49143   {
49144     try {
49145       delete arg1;
49146     } catch (std::out_of_range& e) {
49147       {
49148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49149       };
49150     } catch (std::exception& e) {
49151       {
49152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49153       };
49154     } catch (Dali::DaliException e) {
49155       {
49156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49157       };
49158     } catch (...) {
49159       {
49160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49161       };
49162     }
49163   }
49164
49165 }
49166
49167
49168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49169   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49170
49171   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49172   {
49173     try {
49174       (arg1)->clear();
49175     } catch (std::out_of_range& e) {
49176       {
49177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49178       };
49179     } catch (std::exception& e) {
49180       {
49181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49182       };
49183     } catch (Dali::DaliException e) {
49184       {
49185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49186       };
49187     } catch (...) {
49188       {
49189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49190       };
49191     }
49192   }
49193
49194 }
49195
49196
49197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49198   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49199   Dali::TouchPoint *arg2 = 0 ;
49200
49201   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49202   arg2 = (Dali::TouchPoint *)jarg2;
49203   if (!arg2) {
49204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49205     return ;
49206   }
49207   {
49208     try {
49209       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49210     } catch (std::out_of_range& e) {
49211       {
49212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49213       };
49214     } catch (std::exception& e) {
49215       {
49216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49217       };
49218     } catch (Dali::DaliException e) {
49219       {
49220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49221       };
49222     } catch (...) {
49223       {
49224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49225       };
49226     }
49227   }
49228
49229 }
49230
49231
49232 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49233   unsigned long jresult ;
49234   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49235   std::vector< Dali::TouchPoint >::size_type result;
49236
49237   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49238   {
49239     try {
49240       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49241     } catch (std::out_of_range& e) {
49242       {
49243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49244       };
49245     } catch (std::exception& e) {
49246       {
49247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49248       };
49249     } catch (Dali::DaliException e) {
49250       {
49251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49252       };
49253     } catch (...) {
49254       {
49255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49256       };
49257     }
49258   }
49259
49260   jresult = (unsigned long)result;
49261   return jresult;
49262 }
49263
49264
49265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49266   unsigned long jresult ;
49267   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49268   std::vector< Dali::TouchPoint >::size_type result;
49269
49270   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49271   {
49272     try {
49273       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49274     } catch (std::out_of_range& e) {
49275       {
49276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49277       };
49278     } catch (std::exception& e) {
49279       {
49280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49281       };
49282     } catch (Dali::DaliException e) {
49283       {
49284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49285       };
49286     } catch (...) {
49287       {
49288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49289       };
49290     }
49291   }
49292
49293   jresult = (unsigned long)result;
49294   return jresult;
49295 }
49296
49297
49298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49299   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49300   std::vector< Dali::TouchPoint >::size_type arg2 ;
49301
49302   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49303   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49304   {
49305     try {
49306       (arg1)->reserve(arg2);
49307     } catch (std::out_of_range& e) {
49308       {
49309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49310       };
49311     } catch (std::exception& e) {
49312       {
49313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49314       };
49315     } catch (Dali::DaliException e) {
49316       {
49317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49318       };
49319     } catch (...) {
49320       {
49321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49322       };
49323     }
49324   }
49325
49326 }
49327
49328
49329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49330   void * jresult ;
49331   std::vector< Dali::TouchPoint > *result = 0 ;
49332
49333   {
49334     try {
49335       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49336     } catch (std::out_of_range& e) {
49337       {
49338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49339       };
49340     } catch (std::exception& e) {
49341       {
49342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49343       };
49344     } catch (Dali::DaliException e) {
49345       {
49346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49347       };
49348     } catch (...) {
49349       {
49350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49351       };
49352     }
49353   }
49354
49355   jresult = (void *)result;
49356   return jresult;
49357 }
49358
49359
49360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49361   void * jresult ;
49362   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49363   std::vector< Dali::TouchPoint > *result = 0 ;
49364
49365   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49366   if (!arg1) {
49367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49368     return 0;
49369   }
49370   {
49371     try {
49372       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49373     } catch (std::out_of_range& e) {
49374       {
49375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49376       };
49377     } catch (std::exception& e) {
49378       {
49379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49380       };
49381     } catch (Dali::DaliException e) {
49382       {
49383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49384       };
49385     } catch (...) {
49386       {
49387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49388       };
49389     }
49390   }
49391
49392   jresult = (void *)result;
49393   return jresult;
49394 }
49395
49396
49397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49398   void * jresult ;
49399   int arg1 ;
49400   std::vector< Dali::TouchPoint > *result = 0 ;
49401
49402   arg1 = (int)jarg1;
49403   {
49404     try {
49405       try {
49406         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49407       }
49408       catch(std::out_of_range &_e) {
49409         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49410         return 0;
49411       }
49412
49413     } catch (std::out_of_range& e) {
49414       {
49415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49416       };
49417     } catch (std::exception& e) {
49418       {
49419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49420       };
49421     } catch (Dali::DaliException e) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49424       };
49425     } catch (...) {
49426       {
49427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49428       };
49429     }
49430   }
49431
49432   jresult = (void *)result;
49433   return jresult;
49434 }
49435
49436
49437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49438   void * jresult ;
49439   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49440   int arg2 ;
49441   SwigValueWrapper< Dali::TouchPoint > result;
49442
49443   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49444   arg2 = (int)jarg2;
49445   {
49446     try {
49447       try {
49448         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49449       }
49450       catch(std::out_of_range &_e) {
49451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49452         return 0;
49453       }
49454
49455     } catch (std::out_of_range& e) {
49456       {
49457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49458       };
49459     } catch (std::exception& e) {
49460       {
49461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49462       };
49463     } catch (Dali::DaliException e) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49466       };
49467     } catch (...) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49470       };
49471     }
49472   }
49473
49474   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49475   return jresult;
49476 }
49477
49478
49479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49480   void * jresult ;
49481   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49482   int arg2 ;
49483   Dali::TouchPoint *result = 0 ;
49484
49485   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49486   arg2 = (int)jarg2;
49487   {
49488     try {
49489       try {
49490         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49491       }
49492       catch(std::out_of_range &_e) {
49493         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49494         return 0;
49495       }
49496
49497     } catch (std::out_of_range& e) {
49498       {
49499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (std::exception& e) {
49502       {
49503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49504       };
49505     } catch (Dali::DaliException e) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49508       };
49509     } catch (...) {
49510       {
49511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49512       };
49513     }
49514   }
49515
49516   jresult = (void *)result;
49517   return jresult;
49518 }
49519
49520
49521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49522   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49523   int arg2 ;
49524   Dali::TouchPoint *arg3 = 0 ;
49525
49526   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49527   arg2 = (int)jarg2;
49528   arg3 = (Dali::TouchPoint *)jarg3;
49529   if (!arg3) {
49530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49531     return ;
49532   }
49533   {
49534     try {
49535       try {
49536         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49537       }
49538       catch(std::out_of_range &_e) {
49539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49540         return ;
49541       }
49542
49543     } catch (std::out_of_range& e) {
49544       {
49545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49546       };
49547     } catch (std::exception& e) {
49548       {
49549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49550       };
49551     } catch (Dali::DaliException e) {
49552       {
49553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49554       };
49555     } catch (...) {
49556       {
49557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49558       };
49559     }
49560   }
49561
49562 }
49563
49564
49565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49566   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49567   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49568
49569   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49570   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49571   if (!arg2) {
49572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49573     return ;
49574   }
49575   {
49576     try {
49577       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49578     } catch (std::out_of_range& e) {
49579       {
49580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49581       };
49582     } catch (std::exception& e) {
49583       {
49584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49585       };
49586     } catch (Dali::DaliException e) {
49587       {
49588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49589       };
49590     } catch (...) {
49591       {
49592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49593       };
49594     }
49595   }
49596
49597 }
49598
49599
49600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49601   void * jresult ;
49602   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49603   int arg2 ;
49604   int arg3 ;
49605   std::vector< Dali::TouchPoint > *result = 0 ;
49606
49607   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49608   arg2 = (int)jarg2;
49609   arg3 = (int)jarg3;
49610   {
49611     try {
49612       try {
49613         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49614       }
49615       catch(std::out_of_range &_e) {
49616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49617         return 0;
49618       }
49619       catch(std::invalid_argument &_e) {
49620         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49621         return 0;
49622       }
49623
49624     } catch (std::out_of_range& e) {
49625       {
49626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49627       };
49628     } catch (std::exception& e) {
49629       {
49630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49631       };
49632     } catch (Dali::DaliException e) {
49633       {
49634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49635       };
49636     } catch (...) {
49637       {
49638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49639       };
49640     }
49641   }
49642
49643   jresult = (void *)result;
49644   return jresult;
49645 }
49646
49647
49648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49649   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49650   int arg2 ;
49651   Dali::TouchPoint *arg3 = 0 ;
49652
49653   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49654   arg2 = (int)jarg2;
49655   arg3 = (Dali::TouchPoint *)jarg3;
49656   if (!arg3) {
49657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49658     return ;
49659   }
49660   {
49661     try {
49662       try {
49663         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49664       }
49665       catch(std::out_of_range &_e) {
49666         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49667         return ;
49668       }
49669
49670     } catch (std::out_of_range& e) {
49671       {
49672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49673       };
49674     } catch (std::exception& e) {
49675       {
49676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49677       };
49678     } catch (Dali::DaliException e) {
49679       {
49680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49681       };
49682     } catch (...) {
49683       {
49684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49685       };
49686     }
49687   }
49688
49689 }
49690
49691
49692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49693   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49694   int arg2 ;
49695   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49696
49697   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49698   arg2 = (int)jarg2;
49699   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49700   if (!arg3) {
49701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49702     return ;
49703   }
49704   {
49705     try {
49706       try {
49707         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49708       }
49709       catch(std::out_of_range &_e) {
49710         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49711         return ;
49712       }
49713
49714     } catch (std::out_of_range& e) {
49715       {
49716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49717       };
49718     } catch (std::exception& e) {
49719       {
49720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49721       };
49722     } catch (Dali::DaliException e) {
49723       {
49724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49725       };
49726     } catch (...) {
49727       {
49728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49729       };
49730     }
49731   }
49732
49733 }
49734
49735
49736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49737   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49738   int arg2 ;
49739
49740   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49741   arg2 = (int)jarg2;
49742   {
49743     try {
49744       try {
49745         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49746       }
49747       catch(std::out_of_range &_e) {
49748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49749         return ;
49750       }
49751
49752     } catch (std::out_of_range& e) {
49753       {
49754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49755       };
49756     } catch (std::exception& e) {
49757       {
49758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49759       };
49760     } catch (Dali::DaliException e) {
49761       {
49762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49763       };
49764     } catch (...) {
49765       {
49766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49767       };
49768     }
49769   }
49770
49771 }
49772
49773
49774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49775   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49776   int arg2 ;
49777   int arg3 ;
49778
49779   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49780   arg2 = (int)jarg2;
49781   arg3 = (int)jarg3;
49782   {
49783     try {
49784       try {
49785         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49786       }
49787       catch(std::out_of_range &_e) {
49788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49789         return ;
49790       }
49791       catch(std::invalid_argument &_e) {
49792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49793         return ;
49794       }
49795
49796     } catch (std::out_of_range& e) {
49797       {
49798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49799       };
49800     } catch (std::exception& e) {
49801       {
49802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (Dali::DaliException e) {
49805       {
49806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49807       };
49808     } catch (...) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49811       };
49812     }
49813   }
49814
49815 }
49816
49817
49818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49819   void * jresult ;
49820   Dali::TouchPoint *arg1 = 0 ;
49821   int arg2 ;
49822   std::vector< Dali::TouchPoint > *result = 0 ;
49823
49824   arg1 = (Dali::TouchPoint *)jarg1;
49825   if (!arg1) {
49826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49827     return 0;
49828   }
49829   arg2 = (int)jarg2;
49830   {
49831     try {
49832       try {
49833         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49834       }
49835       catch(std::out_of_range &_e) {
49836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49837         return 0;
49838       }
49839
49840     } catch (std::out_of_range& e) {
49841       {
49842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49843       };
49844     } catch (std::exception& e) {
49845       {
49846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49847       };
49848     } catch (Dali::DaliException e) {
49849       {
49850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49851       };
49852     } catch (...) {
49853       {
49854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49855       };
49856     }
49857   }
49858
49859   jresult = (void *)result;
49860   return jresult;
49861 }
49862
49863
49864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49865   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49866
49867   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49868   {
49869     try {
49870       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49871     } catch (std::out_of_range& e) {
49872       {
49873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49874       };
49875     } catch (std::exception& e) {
49876       {
49877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49878       };
49879     } catch (Dali::DaliException e) {
49880       {
49881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49882       };
49883     } catch (...) {
49884       {
49885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49886       };
49887     }
49888   }
49889
49890 }
49891
49892
49893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49894   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49895   int arg2 ;
49896   int arg3 ;
49897
49898   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49899   arg2 = (int)jarg2;
49900   arg3 = (int)jarg3;
49901   {
49902     try {
49903       try {
49904         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49905       }
49906       catch(std::out_of_range &_e) {
49907         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49908         return ;
49909       }
49910       catch(std::invalid_argument &_e) {
49911         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49912         return ;
49913       }
49914
49915     } catch (std::out_of_range& e) {
49916       {
49917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49918       };
49919     } catch (std::exception& e) {
49920       {
49921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49922       };
49923     } catch (Dali::DaliException e) {
49924       {
49925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49926       };
49927     } catch (...) {
49928       {
49929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49930       };
49931     }
49932   }
49933
49934 }
49935
49936
49937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49938   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49939   int arg2 ;
49940   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49941
49942   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49943   arg2 = (int)jarg2;
49944   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49945   if (!arg3) {
49946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49947     return ;
49948   }
49949   {
49950     try {
49951       try {
49952         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49953       }
49954       catch(std::out_of_range &_e) {
49955         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49956         return ;
49957       }
49958
49959     } catch (std::out_of_range& e) {
49960       {
49961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (std::exception& e) {
49964       {
49965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (Dali::DaliException e) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49970       };
49971     } catch (...) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49974       };
49975     }
49976   }
49977
49978 }
49979
49980
49981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49982   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49983
49984   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49985   {
49986     try {
49987       delete arg1;
49988     } catch (std::out_of_range& e) {
49989       {
49990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49991       };
49992     } catch (std::exception& e) {
49993       {
49994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49995       };
49996     } catch (Dali::DaliException e) {
49997       {
49998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49999       };
50000     } catch (...) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50003       };
50004     }
50005   }
50006
50007 }
50008
50009
50010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50011   void * jresult ;
50012   Dali::Rect< int > *result = 0 ;
50013
50014   {
50015     try {
50016       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50017     } catch (std::out_of_range& e) {
50018       {
50019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50020       };
50021     } catch (std::exception& e) {
50022       {
50023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50024       };
50025     } catch (Dali::DaliException e) {
50026       {
50027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50028       };
50029     } catch (...) {
50030       {
50031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50032       };
50033     }
50034   }
50035
50036   jresult = (void *)result;
50037   return jresult;
50038 }
50039
50040
50041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50042   void * jresult ;
50043   int arg1 ;
50044   int arg2 ;
50045   int arg3 ;
50046   int arg4 ;
50047   Dali::Rect< int > *result = 0 ;
50048
50049   arg1 = (int)jarg1;
50050   arg2 = (int)jarg2;
50051   arg3 = (int)jarg3;
50052   arg4 = (int)jarg4;
50053   {
50054     try {
50055       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
50056     } catch (std::out_of_range& e) {
50057       {
50058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50059       };
50060     } catch (std::exception& e) {
50061       {
50062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50063       };
50064     } catch (Dali::DaliException e) {
50065       {
50066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50067       };
50068     } catch (...) {
50069       {
50070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50071       };
50072     }
50073   }
50074
50075   jresult = (void *)result;
50076   return jresult;
50077 }
50078
50079
50080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
50081   void * jresult ;
50082   Dali::Rect< int > *arg1 = 0 ;
50083   Dali::Rect< int > *result = 0 ;
50084
50085   arg1 = (Dali::Rect< int > *)jarg1;
50086   if (!arg1) {
50087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50088     return 0;
50089   }
50090   {
50091     try {
50092       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50093     } catch (std::out_of_range& e) {
50094       {
50095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50096       };
50097     } catch (std::exception& e) {
50098       {
50099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50100       };
50101     } catch (Dali::DaliException e) {
50102       {
50103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50104       };
50105     } catch (...) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50108       };
50109     }
50110   }
50111
50112   jresult = (void *)result;
50113   return jresult;
50114 }
50115
50116
50117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50118   void * jresult ;
50119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50120   Dali::Rect< int > *arg2 = 0 ;
50121   Dali::Rect< int > *result = 0 ;
50122
50123   arg1 = (Dali::Rect< int > *)jarg1;
50124   arg2 = (Dali::Rect< int > *)jarg2;
50125   if (!arg2) {
50126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50127     return 0;
50128   }
50129   {
50130     try {
50131       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
50132     } catch (std::out_of_range& e) {
50133       {
50134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50135       };
50136     } catch (std::exception& e) {
50137       {
50138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50139       };
50140     } catch (Dali::DaliException e) {
50141       {
50142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50143       };
50144     } catch (...) {
50145       {
50146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50147       };
50148     }
50149   }
50150
50151   jresult = (void *)result;
50152   return jresult;
50153 }
50154
50155
50156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50157   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50158   int arg2 ;
50159   int arg3 ;
50160   int arg4 ;
50161   int arg5 ;
50162
50163   arg1 = (Dali::Rect< int > *)jarg1;
50164   arg2 = (int)jarg2;
50165   arg3 = (int)jarg3;
50166   arg4 = (int)jarg4;
50167   arg5 = (int)jarg5;
50168   {
50169     try {
50170       (arg1)->Set(arg2,arg3,arg4,arg5);
50171     } catch (std::out_of_range& e) {
50172       {
50173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50174       };
50175     } catch (std::exception& e) {
50176       {
50177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50178       };
50179     } catch (Dali::DaliException e) {
50180       {
50181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50182       };
50183     } catch (...) {
50184       {
50185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50186       };
50187     }
50188   }
50189
50190 }
50191
50192
50193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50194   unsigned int jresult ;
50195   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50196   bool result;
50197
50198   arg1 = (Dali::Rect< int > *)jarg1;
50199   {
50200     try {
50201       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50202     } catch (std::out_of_range& e) {
50203       {
50204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50205       };
50206     } catch (std::exception& e) {
50207       {
50208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50209       };
50210     } catch (Dali::DaliException e) {
50211       {
50212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50213       };
50214     } catch (...) {
50215       {
50216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50217       };
50218     }
50219   }
50220
50221   jresult = result;
50222   return jresult;
50223 }
50224
50225
50226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50227   int jresult ;
50228   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50229   int result;
50230
50231   arg1 = (Dali::Rect< int > *)jarg1;
50232   {
50233     try {
50234       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50235     } catch (std::out_of_range& e) {
50236       {
50237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50238       };
50239     } catch (std::exception& e) {
50240       {
50241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50242       };
50243     } catch (Dali::DaliException e) {
50244       {
50245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50246       };
50247     } catch (...) {
50248       {
50249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50250       };
50251     }
50252   }
50253
50254   jresult = result;
50255   return jresult;
50256 }
50257
50258
50259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50260   int jresult ;
50261   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50262   int result;
50263
50264   arg1 = (Dali::Rect< int > *)jarg1;
50265   {
50266     try {
50267       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50268     } catch (std::out_of_range& e) {
50269       {
50270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50271       };
50272     } catch (std::exception& e) {
50273       {
50274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50275       };
50276     } catch (Dali::DaliException e) {
50277       {
50278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50279       };
50280     } catch (...) {
50281       {
50282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50283       };
50284     }
50285   }
50286
50287   jresult = result;
50288   return jresult;
50289 }
50290
50291
50292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50293   int jresult ;
50294   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50295   int result;
50296
50297   arg1 = (Dali::Rect< int > *)jarg1;
50298   {
50299     try {
50300       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50301     } catch (std::out_of_range& e) {
50302       {
50303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50304       };
50305     } catch (std::exception& e) {
50306       {
50307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50308       };
50309     } catch (Dali::DaliException e) {
50310       {
50311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50312       };
50313     } catch (...) {
50314       {
50315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50316       };
50317     }
50318   }
50319
50320   jresult = result;
50321   return jresult;
50322 }
50323
50324
50325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50326   int jresult ;
50327   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50328   int result;
50329
50330   arg1 = (Dali::Rect< int > *)jarg1;
50331   {
50332     try {
50333       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50334     } catch (std::out_of_range& e) {
50335       {
50336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50337       };
50338     } catch (std::exception& e) {
50339       {
50340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50341       };
50342     } catch (Dali::DaliException e) {
50343       {
50344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50345       };
50346     } catch (...) {
50347       {
50348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50349       };
50350     }
50351   }
50352
50353   jresult = result;
50354   return jresult;
50355 }
50356
50357
50358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50359   int jresult ;
50360   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50361   int result;
50362
50363   arg1 = (Dali::Rect< int > *)jarg1;
50364   {
50365     try {
50366       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50367     } catch (std::out_of_range& e) {
50368       {
50369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50370       };
50371     } catch (std::exception& e) {
50372       {
50373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50374       };
50375     } catch (Dali::DaliException e) {
50376       {
50377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50378       };
50379     } catch (...) {
50380       {
50381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50382       };
50383     }
50384   }
50385
50386   jresult = result;
50387   return jresult;
50388 }
50389
50390
50391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50392   unsigned int jresult ;
50393   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50394   Dali::Rect< int > *arg2 = 0 ;
50395   bool result;
50396
50397   arg1 = (Dali::Rect< int > *)jarg1;
50398   arg2 = (Dali::Rect< int > *)jarg2;
50399   if (!arg2) {
50400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50401     return 0;
50402   }
50403   {
50404     try {
50405       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
50406     } catch (std::out_of_range& e) {
50407       {
50408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50409       };
50410     } catch (std::exception& e) {
50411       {
50412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50413       };
50414     } catch (Dali::DaliException e) {
50415       {
50416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50417       };
50418     } catch (...) {
50419       {
50420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50421       };
50422     }
50423   }
50424
50425   jresult = result;
50426   return jresult;
50427 }
50428
50429
50430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
50431   unsigned int jresult ;
50432   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50433   Dali::Rect< int > *arg2 = 0 ;
50434   bool result;
50435
50436   arg1 = (Dali::Rect< int > *)jarg1;
50437   arg2 = (Dali::Rect< int > *)jarg2;
50438   if (!arg2) {
50439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50440     return 0;
50441   }
50442   {
50443     try {
50444       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
50445     } catch (std::out_of_range& e) {
50446       {
50447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50448       };
50449     } catch (std::exception& e) {
50450       {
50451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50452       };
50453     } catch (Dali::DaliException e) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50460       };
50461     }
50462   }
50463
50464   jresult = result;
50465   return jresult;
50466 }
50467
50468
50469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50470   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50471   int arg2 ;
50472
50473   arg1 = (Dali::Rect< int > *)jarg1;
50474   arg2 = (int)jarg2;
50475   if (arg1) (arg1)->x = arg2;
50476 }
50477
50478
50479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50480   int jresult ;
50481   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50482   int result;
50483
50484   arg1 = (Dali::Rect< int > *)jarg1;
50485   result = (int) ((arg1)->x);
50486   jresult = result;
50487   return jresult;
50488 }
50489
50490
50491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50492   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50493   int arg2 ;
50494
50495   arg1 = (Dali::Rect< int > *)jarg1;
50496   arg2 = (int)jarg2;
50497   if (arg1) (arg1)->left = arg2;
50498 }
50499
50500
50501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50502   int jresult ;
50503   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50504   int result;
50505
50506   arg1 = (Dali::Rect< int > *)jarg1;
50507   result = (int) ((arg1)->left);
50508   jresult = result;
50509   return jresult;
50510 }
50511
50512
50513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50514   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50515   int arg2 ;
50516
50517   arg1 = (Dali::Rect< int > *)jarg1;
50518   arg2 = (int)jarg2;
50519   if (arg1) (arg1)->y = arg2;
50520 }
50521
50522
50523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50524   int jresult ;
50525   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50526   int result;
50527
50528   arg1 = (Dali::Rect< int > *)jarg1;
50529   result = (int) ((arg1)->y);
50530   jresult = result;
50531   return jresult;
50532 }
50533
50534
50535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50536   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50537   int arg2 ;
50538
50539   arg1 = (Dali::Rect< int > *)jarg1;
50540   arg2 = (int)jarg2;
50541   if (arg1) (arg1)->right = arg2;
50542 }
50543
50544
50545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50546   int jresult ;
50547   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50548   int result;
50549
50550   arg1 = (Dali::Rect< int > *)jarg1;
50551   result = (int) ((arg1)->right);
50552   jresult = result;
50553   return jresult;
50554 }
50555
50556
50557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50558   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50559   int arg2 ;
50560
50561   arg1 = (Dali::Rect< int > *)jarg1;
50562   arg2 = (int)jarg2;
50563   if (arg1) (arg1)->width = arg2;
50564 }
50565
50566
50567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50568   int jresult ;
50569   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50570   int result;
50571
50572   arg1 = (Dali::Rect< int > *)jarg1;
50573   result = (int) ((arg1)->width);
50574   jresult = result;
50575   return jresult;
50576 }
50577
50578
50579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50580   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50581   int arg2 ;
50582
50583   arg1 = (Dali::Rect< int > *)jarg1;
50584   arg2 = (int)jarg2;
50585   if (arg1) (arg1)->bottom = arg2;
50586 }
50587
50588
50589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50590   int jresult ;
50591   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50592   int result;
50593
50594   arg1 = (Dali::Rect< int > *)jarg1;
50595   result = (int) ((arg1)->bottom);
50596   jresult = result;
50597   return jresult;
50598 }
50599
50600
50601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50602   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50603   int arg2 ;
50604
50605   arg1 = (Dali::Rect< int > *)jarg1;
50606   arg2 = (int)jarg2;
50607   if (arg1) (arg1)->height = arg2;
50608 }
50609
50610
50611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50612   int jresult ;
50613   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50614   int result;
50615
50616   arg1 = (Dali::Rect< int > *)jarg1;
50617   result = (int) ((arg1)->height);
50618   jresult = result;
50619   return jresult;
50620 }
50621
50622
50623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50624   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50625   int arg2 ;
50626
50627   arg1 = (Dali::Rect< int > *)jarg1;
50628   arg2 = (int)jarg2;
50629   if (arg1) (arg1)->top = arg2;
50630 }
50631
50632
50633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50634   int jresult ;
50635   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50636   int result;
50637
50638   arg1 = (Dali::Rect< int > *)jarg1;
50639   result = (int) ((arg1)->top);
50640   jresult = result;
50641   return jresult;
50642 }
50643
50644
50645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50646   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50647
50648   arg1 = (Dali::Rect< int > *)jarg1;
50649   {
50650     try {
50651       delete arg1;
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50659       };
50660     } catch (Dali::DaliException e) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50667       };
50668     }
50669   }
50670
50671 }
50672
50673
50674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50675   void * jresult ;
50676   Dali::Rect< float > *result = 0 ;
50677
50678   {
50679     try {
50680       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50681     } catch (std::out_of_range& e) {
50682       {
50683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50684       };
50685     } catch (std::exception& e) {
50686       {
50687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50688       };
50689     } catch (Dali::DaliException e) {
50690       {
50691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50692       };
50693     } catch (...) {
50694       {
50695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50696       };
50697     }
50698   }
50699
50700   jresult = (void *)result;
50701   return jresult;
50702 }
50703
50704
50705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50706   void * jresult ;
50707   float arg1 ;
50708   float arg2 ;
50709   float arg3 ;
50710   float arg4 ;
50711   Dali::Rect< float > *result = 0 ;
50712
50713   arg1 = (float)jarg1;
50714   arg2 = (float)jarg2;
50715   arg3 = (float)jarg4;
50716   arg4 = (float)jarg3;
50717   {
50718     try {
50719       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
50720     } catch (std::out_of_range& e) {
50721       {
50722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50723       };
50724     } catch (std::exception& e) {
50725       {
50726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50727       };
50728     } catch (Dali::DaliException e) {
50729       {
50730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50731       };
50732     } catch (...) {
50733       {
50734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50735       };
50736     }
50737   }
50738
50739   jresult = (void *)result;
50740   return jresult;
50741 }
50742
50743
50744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
50745   void * jresult ;
50746   Dali::Rect< float > *arg1 = 0 ;
50747   Dali::Rect< float > *result = 0 ;
50748
50749   arg1 = (Dali::Rect< float > *)jarg1;
50750   if (!arg1) {
50751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50752     return 0;
50753   }
50754   {
50755     try {
50756       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50757     } catch (std::out_of_range& e) {
50758       {
50759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50760       };
50761     } catch (std::exception& e) {
50762       {
50763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50764       };
50765     } catch (Dali::DaliException e) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50772       };
50773     }
50774   }
50775
50776   jresult = (void *)result;
50777   return jresult;
50778 }
50779
50780
50781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50782   void * jresult ;
50783   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50784   Dali::Rect< float > *arg2 = 0 ;
50785   Dali::Rect< float > *result = 0 ;
50786
50787   arg1 = (Dali::Rect< float > *)jarg1;
50788   arg2 = (Dali::Rect< float > *)jarg2;
50789   if (!arg2) {
50790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50791     return 0;
50792   }
50793   {
50794     try {
50795       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
50796     } catch (std::out_of_range& e) {
50797       {
50798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50799       };
50800     } catch (std::exception& e) {
50801       {
50802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50803       };
50804     } catch (Dali::DaliException e) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50807       };
50808     } catch (...) {
50809       {
50810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50811       };
50812     }
50813   }
50814
50815   jresult = (void *)result;
50816   return jresult;
50817 }
50818
50819
50820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50821   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50822   float arg2 ;
50823   float arg3 ;
50824   float arg4 ;
50825   float arg5 ;
50826
50827   arg1 = (Dali::Rect< float > *)jarg1;
50828   arg2 = (float)jarg2;
50829   arg3 = (float)jarg3;
50830   arg4 = (float)jarg5;
50831   arg5 = (float)jarg4;
50832   {
50833     try {
50834       (arg1)->Set(arg2,arg3,arg4,arg5);
50835     } catch (std::out_of_range& e) {
50836       {
50837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50838       };
50839     } catch (std::exception& e) {
50840       {
50841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50842       };
50843     } catch (Dali::DaliException e) {
50844       {
50845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50846       };
50847     } catch (...) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50850       };
50851     }
50852   }
50853
50854 }
50855
50856
50857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50858   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50859   float arg2 ;
50860
50861   arg1 = (Dali::Rect< float > *)jarg1;
50862   arg2 = (float)jarg2;
50863   if (arg1) (arg1)->left = arg2;
50864 }
50865
50866
50867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50868   float jresult ;
50869   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50870   float result;
50871
50872   arg1 = (Dali::Rect< float > *)jarg1;
50873   result = (float) ((arg1)->left);
50874   jresult = result;
50875   return jresult;
50876 }
50877
50878
50879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50880   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50881   float arg2 ;
50882
50883   arg1 = (Dali::Rect< float > *)jarg1;
50884   arg2 = (float)jarg2;
50885   if (arg1) (arg1)->left = arg2;
50886 }
50887
50888
50889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50890   float jresult ;
50891   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50892   float result;
50893
50894   arg1 = (Dali::Rect< float > *)jarg1;
50895   result = (float) ((arg1)->left);
50896   jresult = result;
50897   return jresult;
50898 }
50899
50900
50901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50902   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50903   float arg2 ;
50904
50905   arg1 = (Dali::Rect< float > *)jarg1;
50906   arg2 = (float)jarg2;
50907   if (arg1) (arg1)->right = arg2;
50908 }
50909
50910
50911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50912   float jresult ;
50913   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50914   float result;
50915
50916   arg1 = (Dali::Rect< float > *)jarg1;
50917   result = (float) ((arg1)->right);
50918   jresult = result;
50919   return jresult;
50920 }
50921
50922
50923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50924   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50925   float arg2 ;
50926
50927   arg1 = (Dali::Rect< float > *)jarg1;
50928   arg2 = (float)jarg2;
50929   if (arg1) (arg1)->right = arg2;
50930 }
50931
50932
50933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50934   float jresult ;
50935   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50936   float result;
50937
50938   arg1 = (Dali::Rect< float > *)jarg1;
50939   result = (float) ((arg1)->right);
50940   jresult = result;
50941   return jresult;
50942 }
50943
50944
50945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50946   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50947   float arg2 ;
50948
50949   arg1 = (Dali::Rect< float > *)jarg1;
50950   arg2 = (float)jarg2;
50951   if (arg1) (arg1)->bottom = arg2;
50952 }
50953
50954
50955 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50956   float jresult ;
50957   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50958   float result;
50959
50960   arg1 = (Dali::Rect< float > *)jarg1;
50961   result = (float) ((arg1)->bottom);
50962   jresult = result;
50963   return jresult;
50964 }
50965
50966
50967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50968   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50969   float arg2 ;
50970
50971   arg1 = (Dali::Rect< float > *)jarg1;
50972   arg2 = (float)jarg2;
50973   if (arg1) (arg1)->top = arg2;
50974 }
50975
50976
50977 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50978   float jresult ;
50979   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50980   float result;
50981
50982   arg1 = (Dali::Rect< float > *)jarg1;
50983   result = (float) ((arg1)->top);
50984   jresult = result;
50985   return jresult;
50986 }
50987
50988
50989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50990   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50991
50992   arg1 = (Dali::Rect< float > *)jarg1;
50993   {
50994     try {
50995       delete arg1;
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51011       };
51012     }
51013   }
51014
51015 }
51016
51017
51018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51019   int jresult ;
51020   int result;
51021
51022   result = (int)Dali::Vector< int >::BaseType;
51023   jresult = (int)result;
51024   return jresult;
51025 }
51026
51027
51028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51029   void * jresult ;
51030   Dali::Vector< int > *result = 0 ;
51031
51032   {
51033     try {
51034       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51035     } catch (std::out_of_range& e) {
51036       {
51037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51038       };
51039     } catch (std::exception& e) {
51040       {
51041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51042       };
51043     } catch (Dali::DaliException e) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51046       };
51047     } catch (...) {
51048       {
51049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51050       };
51051     }
51052   }
51053
51054   jresult = (void *)result;
51055   return jresult;
51056 }
51057
51058
51059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51060   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51061
51062   arg1 = (Dali::Vector< int > *)jarg1;
51063   {
51064     try {
51065       delete arg1;
51066     } catch (std::out_of_range& e) {
51067       {
51068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51069       };
51070     } catch (std::exception& e) {
51071       {
51072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51073       };
51074     } catch (Dali::DaliException e) {
51075       {
51076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51077       };
51078     } catch (...) {
51079       {
51080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51081       };
51082     }
51083   }
51084
51085 }
51086
51087
51088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51089   void * jresult ;
51090   Dali::Vector< int > *arg1 = 0 ;
51091   Dali::Vector< int > *result = 0 ;
51092
51093   arg1 = (Dali::Vector< int > *)jarg1;
51094   if (!arg1) {
51095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51096     return 0;
51097   }
51098   {
51099     try {
51100       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51101     } catch (std::out_of_range& e) {
51102       {
51103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51104       };
51105     } catch (std::exception& e) {
51106       {
51107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51108       };
51109     } catch (Dali::DaliException e) {
51110       {
51111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51112       };
51113     } catch (...) {
51114       {
51115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51116       };
51117     }
51118   }
51119
51120   jresult = (void *)result;
51121   return jresult;
51122 }
51123
51124
51125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51126   void * jresult ;
51127   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51128   Dali::Vector< int > *arg2 = 0 ;
51129   Dali::Vector< int > *result = 0 ;
51130
51131   arg1 = (Dali::Vector< int > *)jarg1;
51132   arg2 = (Dali::Vector< int > *)jarg2;
51133   if (!arg2) {
51134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51135     return 0;
51136   }
51137   {
51138     try {
51139       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
51140     } catch (std::out_of_range& e) {
51141       {
51142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51143       };
51144     } catch (std::exception& e) {
51145       {
51146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51147       };
51148     } catch (Dali::DaliException e) {
51149       {
51150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51151       };
51152     } catch (...) {
51153       {
51154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51155       };
51156     }
51157   }
51158
51159   jresult = (void *)result;
51160   return jresult;
51161 }
51162
51163
51164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
51165   void * jresult ;
51166   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51167   Dali::Vector< int >::Iterator result;
51168
51169   arg1 = (Dali::Vector< int > *)jarg1;
51170   {
51171     try {
51172       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51173     } catch (std::out_of_range& e) {
51174       {
51175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51176       };
51177     } catch (std::exception& e) {
51178       {
51179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51180       };
51181     } catch (Dali::DaliException e) {
51182       {
51183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51184       };
51185     } catch (...) {
51186       {
51187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51188       };
51189     }
51190   }
51191
51192   jresult = (void *)result;
51193   return jresult;
51194 }
51195
51196
51197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51198   void * jresult ;
51199   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51200   Dali::Vector< int >::Iterator result;
51201
51202   arg1 = (Dali::Vector< int > *)jarg1;
51203   {
51204     try {
51205       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51206     } catch (std::out_of_range& e) {
51207       {
51208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51209       };
51210     } catch (std::exception& e) {
51211       {
51212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51213       };
51214     } catch (Dali::DaliException e) {
51215       {
51216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51217       };
51218     } catch (...) {
51219       {
51220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51221       };
51222     }
51223   }
51224
51225   jresult = (void *)result;
51226   return jresult;
51227 }
51228
51229
51230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51231   void * jresult ;
51232   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51233   Dali::Vector< int >::SizeType arg2 ;
51234   Dali::Vector< int >::ItemType *result = 0 ;
51235
51236   arg1 = (Dali::Vector< int > *)jarg1;
51237   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51238   {
51239     try {
51240       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51241     } catch (std::out_of_range& e) {
51242       {
51243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51244       };
51245     } catch (std::exception& e) {
51246       {
51247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51248       };
51249     } catch (Dali::DaliException e) {
51250       {
51251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51252       };
51253     } catch (...) {
51254       {
51255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51256       };
51257     }
51258   }
51259
51260   jresult = (void *)result;
51261   return jresult;
51262 }
51263
51264
51265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51266   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51267   Dali::Vector< int >::ItemType *arg2 = 0 ;
51268   Dali::Vector< int >::ItemType temp2 ;
51269
51270   arg1 = (Dali::Vector< int > *)jarg1;
51271   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51272   arg2 = &temp2;
51273   {
51274     try {
51275       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51276     } catch (std::out_of_range& e) {
51277       {
51278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51279       };
51280     } catch (std::exception& e) {
51281       {
51282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51283       };
51284     } catch (Dali::DaliException e) {
51285       {
51286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51287       };
51288     } catch (...) {
51289       {
51290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51291       };
51292     }
51293   }
51294
51295 }
51296
51297
51298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51299   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51300   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51301   Dali::Vector< int >::ItemType *arg3 = 0 ;
51302   Dali::Vector< int >::ItemType temp3 ;
51303
51304   arg1 = (Dali::Vector< int > *)jarg1;
51305   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51306   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51307   arg3 = &temp3;
51308   {
51309     try {
51310       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51311     } catch (std::out_of_range& e) {
51312       {
51313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51314       };
51315     } catch (std::exception& e) {
51316       {
51317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51318       };
51319     } catch (Dali::DaliException e) {
51320       {
51321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51322       };
51323     } catch (...) {
51324       {
51325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51326       };
51327     }
51328   }
51329
51330 }
51331
51332
51333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51334   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51335   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51336   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51337   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51338
51339   arg1 = (Dali::Vector< int > *)jarg1;
51340   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51341   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51342   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51343   {
51344     try {
51345       (arg1)->Insert(arg2,arg3,arg4);
51346     } catch (std::out_of_range& e) {
51347       {
51348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51349       };
51350     } catch (std::exception& e) {
51351       {
51352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51353       };
51354     } catch (Dali::DaliException e) {
51355       {
51356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51357       };
51358     } catch (...) {
51359       {
51360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51361       };
51362     }
51363   }
51364
51365 }
51366
51367
51368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51369   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51370   Dali::Vector< int >::SizeType arg2 ;
51371
51372   arg1 = (Dali::Vector< int > *)jarg1;
51373   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51374   {
51375     try {
51376       (arg1)->Reserve(arg2);
51377     } catch (std::out_of_range& e) {
51378       {
51379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51380       };
51381     } catch (std::exception& e) {
51382       {
51383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51384       };
51385     } catch (Dali::DaliException e) {
51386       {
51387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51388       };
51389     } catch (...) {
51390       {
51391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51392       };
51393     }
51394   }
51395
51396 }
51397
51398
51399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51400   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51401   Dali::Vector< int >::SizeType arg2 ;
51402
51403   arg1 = (Dali::Vector< int > *)jarg1;
51404   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51405   {
51406     try {
51407       (arg1)->Resize(arg2);
51408     } catch (std::out_of_range& e) {
51409       {
51410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (std::exception& e) {
51413       {
51414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51415       };
51416     } catch (Dali::DaliException e) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51419       };
51420     } catch (...) {
51421       {
51422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51423       };
51424     }
51425   }
51426
51427 }
51428
51429
51430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51431   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51432   Dali::Vector< int >::SizeType arg2 ;
51433   Dali::Vector< int >::ItemType *arg3 = 0 ;
51434   Dali::Vector< int >::ItemType temp3 ;
51435
51436   arg1 = (Dali::Vector< int > *)jarg1;
51437   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51438   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51439   arg3 = &temp3;
51440   {
51441     try {
51442       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51443     } catch (std::out_of_range& e) {
51444       {
51445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51446       };
51447     } catch (std::exception& e) {
51448       {
51449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51450       };
51451     } catch (Dali::DaliException e) {
51452       {
51453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51454       };
51455     } catch (...) {
51456       {
51457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51458       };
51459     }
51460   }
51461
51462 }
51463
51464
51465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51466   void * jresult ;
51467   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51468   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51469   Dali::Vector< int >::Iterator result;
51470
51471   arg1 = (Dali::Vector< int > *)jarg1;
51472   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51473   {
51474     try {
51475       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51476     } catch (std::out_of_range& e) {
51477       {
51478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51479       };
51480     } catch (std::exception& e) {
51481       {
51482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51483       };
51484     } catch (Dali::DaliException e) {
51485       {
51486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51487       };
51488     } catch (...) {
51489       {
51490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51491       };
51492     }
51493   }
51494
51495   jresult = (void *)result;
51496   return jresult;
51497 }
51498
51499
51500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51501   void * jresult ;
51502   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51503   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51504   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51505   Dali::Vector< int >::Iterator result;
51506
51507   arg1 = (Dali::Vector< int > *)jarg1;
51508   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51509   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51510   {
51511     try {
51512       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51513     } catch (std::out_of_range& e) {
51514       {
51515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51516       };
51517     } catch (std::exception& e) {
51518       {
51519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51520       };
51521     } catch (Dali::DaliException e) {
51522       {
51523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51524       };
51525     } catch (...) {
51526       {
51527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51528       };
51529     }
51530   }
51531
51532   jresult = (void *)result;
51533   return jresult;
51534 }
51535
51536
51537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51538   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51539   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51540
51541   arg1 = (Dali::Vector< int > *)jarg1;
51542   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51543   {
51544     try {
51545       (arg1)->Remove(arg2);
51546     } catch (std::out_of_range& e) {
51547       {
51548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51549       };
51550     } catch (std::exception& e) {
51551       {
51552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51553       };
51554     } catch (Dali::DaliException e) {
51555       {
51556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51557       };
51558     } catch (...) {
51559       {
51560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51561       };
51562     }
51563   }
51564
51565 }
51566
51567
51568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51569   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51570   Dali::Vector< int > *arg2 = 0 ;
51571
51572   arg1 = (Dali::Vector< int > *)jarg1;
51573   arg2 = (Dali::Vector< int > *)jarg2;
51574   if (!arg2) {
51575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51576     return ;
51577   }
51578   {
51579     try {
51580       (arg1)->Swap(*arg2);
51581     } catch (std::out_of_range& e) {
51582       {
51583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (std::exception& e) {
51586       {
51587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (Dali::DaliException e) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51592       };
51593     } catch (...) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51596       };
51597     }
51598   }
51599
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51604   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51605
51606   arg1 = (Dali::Vector< int > *)jarg1;
51607   {
51608     try {
51609       (arg1)->Clear();
51610     } catch (std::out_of_range& e) {
51611       {
51612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51613       };
51614     } catch (std::exception& e) {
51615       {
51616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51617       };
51618     } catch (Dali::DaliException e) {
51619       {
51620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51621       };
51622     } catch (...) {
51623       {
51624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51625       };
51626     }
51627   }
51628
51629 }
51630
51631
51632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51633   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51634
51635   arg1 = (Dali::Vector< int > *)jarg1;
51636   {
51637     try {
51638       (arg1)->Release();
51639     } catch (std::out_of_range& e) {
51640       {
51641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51642       };
51643     } catch (std::exception& e) {
51644       {
51645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51646       };
51647     } catch (Dali::DaliException e) {
51648       {
51649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51650       };
51651     } catch (...) {
51652       {
51653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51654       };
51655     }
51656   }
51657
51658 }
51659
51660
51661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51662   int jresult ;
51663   int result;
51664
51665   result = (int)Dali::Vector< float >::BaseType;
51666   jresult = (int)result;
51667   return jresult;
51668 }
51669
51670
51671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51672   void * jresult ;
51673   Dali::Vector< float > *result = 0 ;
51674
51675   {
51676     try {
51677       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51678     } catch (std::out_of_range& e) {
51679       {
51680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51681       };
51682     } catch (std::exception& e) {
51683       {
51684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51685       };
51686     } catch (Dali::DaliException e) {
51687       {
51688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51689       };
51690     } catch (...) {
51691       {
51692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51693       };
51694     }
51695   }
51696
51697   jresult = (void *)result;
51698   return jresult;
51699 }
51700
51701
51702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51703   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51704
51705   arg1 = (Dali::Vector< float > *)jarg1;
51706   {
51707     try {
51708       delete arg1;
51709     } catch (std::out_of_range& e) {
51710       {
51711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51712       };
51713     } catch (std::exception& e) {
51714       {
51715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51716       };
51717     } catch (Dali::DaliException e) {
51718       {
51719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51720       };
51721     } catch (...) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51724       };
51725     }
51726   }
51727
51728 }
51729
51730
51731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51732   void * jresult ;
51733   Dali::Vector< float > *arg1 = 0 ;
51734   Dali::Vector< float > *result = 0 ;
51735
51736   arg1 = (Dali::Vector< float > *)jarg1;
51737   if (!arg1) {
51738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51739     return 0;
51740   }
51741   {
51742     try {
51743       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51744     } catch (std::out_of_range& e) {
51745       {
51746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51747       };
51748     } catch (std::exception& e) {
51749       {
51750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51751       };
51752     } catch (Dali::DaliException e) {
51753       {
51754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51755       };
51756     } catch (...) {
51757       {
51758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51759       };
51760     }
51761   }
51762
51763   jresult = (void *)result;
51764   return jresult;
51765 }
51766
51767
51768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51769   void * jresult ;
51770   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51771   Dali::Vector< float > *arg2 = 0 ;
51772   Dali::Vector< float > *result = 0 ;
51773
51774   arg1 = (Dali::Vector< float > *)jarg1;
51775   arg2 = (Dali::Vector< float > *)jarg2;
51776   if (!arg2) {
51777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51778     return 0;
51779   }
51780   {
51781     try {
51782       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
51783     } catch (std::out_of_range& e) {
51784       {
51785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (std::exception& e) {
51788       {
51789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51790       };
51791     } catch (Dali::DaliException e) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51794       };
51795     } catch (...) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51798       };
51799     }
51800   }
51801
51802   jresult = (void *)result;
51803   return jresult;
51804 }
51805
51806
51807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
51808   void * jresult ;
51809   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51810   Dali::Vector< float >::Iterator result;
51811
51812   arg1 = (Dali::Vector< float > *)jarg1;
51813   {
51814     try {
51815       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51816     } catch (std::out_of_range& e) {
51817       {
51818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (std::exception& e) {
51821       {
51822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (Dali::DaliException e) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834
51835   jresult = (void *)result;
51836   return jresult;
51837 }
51838
51839
51840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51841   void * jresult ;
51842   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51843   Dali::Vector< float >::Iterator result;
51844
51845   arg1 = (Dali::Vector< float > *)jarg1;
51846   {
51847     try {
51848       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51849     } catch (std::out_of_range& e) {
51850       {
51851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51852       };
51853     } catch (std::exception& e) {
51854       {
51855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51856       };
51857     } catch (Dali::DaliException e) {
51858       {
51859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51860       };
51861     } catch (...) {
51862       {
51863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51864       };
51865     }
51866   }
51867
51868   jresult = (void *)result;
51869   return jresult;
51870 }
51871
51872
51873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51874   void * jresult ;
51875   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51876   Dali::Vector< float >::SizeType arg2 ;
51877   Dali::Vector< float >::ItemType *result = 0 ;
51878
51879   arg1 = (Dali::Vector< float > *)jarg1;
51880   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51881   {
51882     try {
51883       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51884     } catch (std::out_of_range& e) {
51885       {
51886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51887       };
51888     } catch (std::exception& e) {
51889       {
51890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (Dali::DaliException e) {
51893       {
51894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51895       };
51896     } catch (...) {
51897       {
51898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51899       };
51900     }
51901   }
51902
51903   jresult = (void *)result;
51904   return jresult;
51905 }
51906
51907
51908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51909   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51910   Dali::Vector< float >::ItemType *arg2 = 0 ;
51911   Dali::Vector< float >::ItemType temp2 ;
51912
51913   arg1 = (Dali::Vector< float > *)jarg1;
51914   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51915   arg2 = &temp2;
51916   {
51917     try {
51918       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51919     } catch (std::out_of_range& e) {
51920       {
51921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51922       };
51923     } catch (std::exception& e) {
51924       {
51925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51926       };
51927     } catch (Dali::DaliException e) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51930       };
51931     } catch (...) {
51932       {
51933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51934       };
51935     }
51936   }
51937
51938 }
51939
51940
51941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51942   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51943   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51944   Dali::Vector< float >::ItemType *arg3 = 0 ;
51945   Dali::Vector< float >::ItemType temp3 ;
51946
51947   arg1 = (Dali::Vector< float > *)jarg1;
51948   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51949   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51950   arg3 = &temp3;
51951   {
51952     try {
51953       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51954     } catch (std::out_of_range& e) {
51955       {
51956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (std::exception& e) {
51959       {
51960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51961       };
51962     } catch (Dali::DaliException e) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51965       };
51966     } catch (...) {
51967       {
51968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51969       };
51970     }
51971   }
51972
51973 }
51974
51975
51976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51977   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51978   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51979   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51980   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51981
51982   arg1 = (Dali::Vector< float > *)jarg1;
51983   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51984   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51985   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51986   {
51987     try {
51988       (arg1)->Insert(arg2,arg3,arg4);
51989     } catch (std::out_of_range& e) {
51990       {
51991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51992       };
51993     } catch (std::exception& e) {
51994       {
51995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51996       };
51997     } catch (Dali::DaliException e) {
51998       {
51999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52000       };
52001     } catch (...) {
52002       {
52003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52004       };
52005     }
52006   }
52007
52008 }
52009
52010
52011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52012   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52013   Dali::Vector< float >::SizeType arg2 ;
52014
52015   arg1 = (Dali::Vector< float > *)jarg1;
52016   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52017   {
52018     try {
52019       (arg1)->Reserve(arg2);
52020     } catch (std::out_of_range& e) {
52021       {
52022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52023       };
52024     } catch (std::exception& e) {
52025       {
52026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52027       };
52028     } catch (Dali::DaliException e) {
52029       {
52030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52031       };
52032     } catch (...) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52035       };
52036     }
52037   }
52038
52039 }
52040
52041 //// ========================= end of part 2 =============================
52042
52043 //// ========================== start part 3 ===============================
52044
52045
52046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52047   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52048   Dali::Vector< float >::SizeType arg2 ;
52049
52050   arg1 = (Dali::Vector< float > *)jarg1;
52051   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52052   {
52053     try {
52054       (arg1)->Resize(arg2);
52055     } catch (std::out_of_range& e) {
52056       {
52057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52058       };
52059     } catch (std::exception& e) {
52060       {
52061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52062       };
52063     } catch (Dali::DaliException e) {
52064       {
52065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52066       };
52067     } catch (...) {
52068       {
52069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52070       };
52071     }
52072   }
52073
52074 }
52075
52076
52077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52078   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52079   Dali::Vector< float >::SizeType arg2 ;
52080   Dali::Vector< float >::ItemType *arg3 = 0 ;
52081   Dali::Vector< float >::ItemType temp3 ;
52082
52083   arg1 = (Dali::Vector< float > *)jarg1;
52084   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52085   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52086   arg3 = &temp3;
52087   {
52088     try {
52089       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52090     } catch (std::out_of_range& e) {
52091       {
52092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52093       };
52094     } catch (std::exception& e) {
52095       {
52096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52097       };
52098     } catch (Dali::DaliException e) {
52099       {
52100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52101       };
52102     } catch (...) {
52103       {
52104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52105       };
52106     }
52107   }
52108
52109 }
52110
52111
52112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52113   void * jresult ;
52114   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52115   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52116   Dali::Vector< float >::Iterator result;
52117
52118   arg1 = (Dali::Vector< float > *)jarg1;
52119   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52120   {
52121     try {
52122       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52123     } catch (std::out_of_range& e) {
52124       {
52125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52126       };
52127     } catch (std::exception& e) {
52128       {
52129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52130       };
52131     } catch (Dali::DaliException e) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52134       };
52135     } catch (...) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52138       };
52139     }
52140   }
52141
52142   jresult = (void *)result;
52143   return jresult;
52144 }
52145
52146
52147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52148   void * jresult ;
52149   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52150   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52151   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52152   Dali::Vector< float >::Iterator result;
52153
52154   arg1 = (Dali::Vector< float > *)jarg1;
52155   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52156   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52157   {
52158     try {
52159       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52160     } catch (std::out_of_range& e) {
52161       {
52162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52163       };
52164     } catch (std::exception& e) {
52165       {
52166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52167       };
52168     } catch (Dali::DaliException e) {
52169       {
52170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52171       };
52172     } catch (...) {
52173       {
52174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52175       };
52176     }
52177   }
52178
52179   jresult = (void *)result;
52180   return jresult;
52181 }
52182
52183
52184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52185   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52186   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52187
52188   arg1 = (Dali::Vector< float > *)jarg1;
52189   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52190   {
52191     try {
52192       (arg1)->Remove(arg2);
52193     } catch (std::out_of_range& e) {
52194       {
52195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52196       };
52197     } catch (std::exception& e) {
52198       {
52199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52200       };
52201     } catch (Dali::DaliException e) {
52202       {
52203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52204       };
52205     } catch (...) {
52206       {
52207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52208       };
52209     }
52210   }
52211
52212 }
52213
52214
52215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52216   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52217   Dali::Vector< float > *arg2 = 0 ;
52218
52219   arg1 = (Dali::Vector< float > *)jarg1;
52220   arg2 = (Dali::Vector< float > *)jarg2;
52221   if (!arg2) {
52222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52223     return ;
52224   }
52225   {
52226     try {
52227       (arg1)->Swap(*arg2);
52228     } catch (std::out_of_range& e) {
52229       {
52230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52231       };
52232     } catch (std::exception& e) {
52233       {
52234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52235       };
52236     } catch (Dali::DaliException e) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52239       };
52240     } catch (...) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52243       };
52244     }
52245   }
52246
52247 }
52248
52249
52250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52251   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52252
52253   arg1 = (Dali::Vector< float > *)jarg1;
52254   {
52255     try {
52256       (arg1)->Clear();
52257     } catch (std::out_of_range& e) {
52258       {
52259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52260       };
52261     } catch (std::exception& e) {
52262       {
52263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52264       };
52265     } catch (Dali::DaliException e) {
52266       {
52267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52268       };
52269     } catch (...) {
52270       {
52271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52272       };
52273     }
52274   }
52275
52276 }
52277
52278
52279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52280   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52281
52282   arg1 = (Dali::Vector< float > *)jarg1;
52283   {
52284     try {
52285       (arg1)->Release();
52286     } catch (std::out_of_range& e) {
52287       {
52288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (std::exception& e) {
52291       {
52292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52293       };
52294     } catch (Dali::DaliException e) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52297       };
52298     } catch (...) {
52299       {
52300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52301       };
52302     }
52303   }
52304
52305 }
52306
52307
52308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52309   int jresult ;
52310   int result;
52311
52312   result = (int)Dali::Vector< unsigned char >::BaseType;
52313   jresult = (int)result;
52314   return jresult;
52315 }
52316
52317
52318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52319   void * jresult ;
52320   Dali::Vector< unsigned char > *result = 0 ;
52321
52322   {
52323     try {
52324       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52325     } catch (std::out_of_range& e) {
52326       {
52327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52328       };
52329     } catch (std::exception& e) {
52330       {
52331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52332       };
52333     } catch (Dali::DaliException e) {
52334       {
52335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52336       };
52337     } catch (...) {
52338       {
52339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52340       };
52341     }
52342   }
52343
52344   jresult = (void *)result;
52345   return jresult;
52346 }
52347
52348
52349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52350   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52351
52352   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52353   {
52354     try {
52355       delete arg1;
52356     } catch (std::out_of_range& e) {
52357       {
52358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52359       };
52360     } catch (std::exception& e) {
52361       {
52362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52363       };
52364     } catch (Dali::DaliException e) {
52365       {
52366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52367       };
52368     } catch (...) {
52369       {
52370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52371       };
52372     }
52373   }
52374
52375 }
52376
52377
52378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52379   void * jresult ;
52380   Dali::Vector< unsigned char > *arg1 = 0 ;
52381   Dali::Vector< unsigned char > *result = 0 ;
52382
52383   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52384   if (!arg1) {
52385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52386     return 0;
52387   }
52388   {
52389     try {
52390       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52398       };
52399     } catch (Dali::DaliException e) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52402       };
52403     } catch (...) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52406       };
52407     }
52408   }
52409
52410   jresult = (void *)result;
52411   return jresult;
52412 }
52413
52414
52415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52416   void * jresult ;
52417   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52418   Dali::Vector< unsigned char > *arg2 = 0 ;
52419   Dali::Vector< unsigned char > *result = 0 ;
52420
52421   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52422   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52423   if (!arg2) {
52424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52425     return 0;
52426   }
52427   {
52428     try {
52429       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
52430     } catch (std::out_of_range& e) {
52431       {
52432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52433       };
52434     } catch (std::exception& e) {
52435       {
52436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52437       };
52438     } catch (Dali::DaliException e) {
52439       {
52440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52441       };
52442     } catch (...) {
52443       {
52444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52445       };
52446     }
52447   }
52448
52449   jresult = (void *)result;
52450   return jresult;
52451 }
52452
52453
52454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
52455   void * jresult ;
52456   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52457   Dali::Vector< unsigned char >::Iterator result;
52458
52459   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52460   {
52461     try {
52462       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52463     } catch (std::out_of_range& e) {
52464       {
52465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52466       };
52467     } catch (std::exception& e) {
52468       {
52469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52470       };
52471     } catch (Dali::DaliException e) {
52472       {
52473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52474       };
52475     } catch (...) {
52476       {
52477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52478       };
52479     }
52480   }
52481
52482   jresult = (void *)result;
52483   return jresult;
52484 }
52485
52486
52487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52488   void * jresult ;
52489   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52490   Dali::Vector< unsigned char >::Iterator result;
52491
52492   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52493   {
52494     try {
52495       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52496     } catch (std::out_of_range& e) {
52497       {
52498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52499       };
52500     } catch (std::exception& e) {
52501       {
52502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52503       };
52504     } catch (Dali::DaliException e) {
52505       {
52506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52507       };
52508     } catch (...) {
52509       {
52510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52511       };
52512     }
52513   }
52514
52515   jresult = (void *)result;
52516   return jresult;
52517 }
52518
52519
52520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52521   void * jresult ;
52522   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52523   Dali::Vector< unsigned char >::SizeType arg2 ;
52524   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52525
52526   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52527   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52528   {
52529     try {
52530       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52531     } catch (std::out_of_range& e) {
52532       {
52533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52534       };
52535     } catch (std::exception& e) {
52536       {
52537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52538       };
52539     } catch (Dali::DaliException e) {
52540       {
52541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52542       };
52543     } catch (...) {
52544       {
52545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52546       };
52547     }
52548   }
52549
52550   jresult = (void *)result;
52551   return jresult;
52552 }
52553
52554
52555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52556   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52557   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52558   Dali::Vector< unsigned char >::ItemType temp2 ;
52559
52560   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52561   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52562   arg2 = &temp2;
52563   {
52564     try {
52565       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52566     } catch (std::out_of_range& e) {
52567       {
52568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52569       };
52570     } catch (std::exception& e) {
52571       {
52572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (Dali::DaliException e) {
52575       {
52576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52577       };
52578     } catch (...) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52581       };
52582     }
52583   }
52584
52585 }
52586
52587
52588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52589   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52590   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52591   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52592   Dali::Vector< unsigned char >::ItemType temp3 ;
52593
52594   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52595   arg2 = jarg2;
52596   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52597   arg3 = &temp3;
52598   {
52599     try {
52600       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52616       };
52617     }
52618   }
52619
52620
52621
52622 }
52623
52624
52625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52626   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52627   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52628   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52629   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52630
52631   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52632   arg2 = jarg2;
52633   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52634   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52635   {
52636     try {
52637       (arg1)->Insert(arg2,arg3,arg4);
52638     } catch (std::out_of_range& e) {
52639       {
52640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52641       };
52642     } catch (std::exception& e) {
52643       {
52644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52645       };
52646     } catch (Dali::DaliException e) {
52647       {
52648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52649       };
52650     } catch (...) {
52651       {
52652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52653       };
52654     }
52655   }
52656
52657
52658
52659 }
52660
52661
52662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52663   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52664   Dali::Vector< unsigned char >::SizeType arg2 ;
52665
52666   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52667   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52668   {
52669     try {
52670       (arg1)->Reserve(arg2);
52671     } catch (std::out_of_range& e) {
52672       {
52673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52674       };
52675     } catch (std::exception& e) {
52676       {
52677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (Dali::DaliException e) {
52680       {
52681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52682       };
52683     } catch (...) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52686       };
52687     }
52688   }
52689
52690 }
52691
52692
52693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52694   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52695   Dali::Vector< unsigned char >::SizeType arg2 ;
52696
52697   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52698   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52699   {
52700     try {
52701       (arg1)->Resize(arg2);
52702     } catch (std::out_of_range& e) {
52703       {
52704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52705       };
52706     } catch (std::exception& e) {
52707       {
52708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52709       };
52710     } catch (Dali::DaliException e) {
52711       {
52712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52713       };
52714     } catch (...) {
52715       {
52716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52717       };
52718     }
52719   }
52720
52721 }
52722
52723
52724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52725   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52726   Dali::Vector< unsigned char >::SizeType arg2 ;
52727   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52728   Dali::Vector< unsigned char >::ItemType temp3 ;
52729
52730   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52731   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52732   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52733   arg3 = &temp3;
52734   {
52735     try {
52736       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52737     } catch (std::out_of_range& e) {
52738       {
52739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52740       };
52741     } catch (std::exception& e) {
52742       {
52743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52744       };
52745     } catch (Dali::DaliException e) {
52746       {
52747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52748       };
52749     } catch (...) {
52750       {
52751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52752       };
52753     }
52754   }
52755
52756 }
52757
52758
52759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52760   void * jresult ;
52761   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52762   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52763   Dali::Vector< unsigned char >::Iterator result;
52764
52765   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52766   arg2 = jarg2;
52767   {
52768     try {
52769       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52770     } catch (std::out_of_range& e) {
52771       {
52772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (std::exception& e) {
52775       {
52776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52777       };
52778     } catch (Dali::DaliException e) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52781       };
52782     } catch (...) {
52783       {
52784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52785       };
52786     }
52787   }
52788
52789   jresult = (void *)result;
52790
52791
52792   return jresult;
52793 }
52794
52795
52796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52797   void * jresult ;
52798   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52799   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52800   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52801   Dali::Vector< unsigned char >::Iterator result;
52802
52803   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52804   arg2 = jarg2;
52805   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52806   {
52807     try {
52808       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
52809     } catch (std::out_of_range& e) {
52810       {
52811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52812       };
52813     } catch (std::exception& e) {
52814       {
52815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52816       };
52817     } catch (Dali::DaliException e) {
52818       {
52819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52820       };
52821     } catch (...) {
52822       {
52823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52824       };
52825     }
52826   }
52827
52828   jresult = (void *)result;
52829
52830
52831   return jresult;
52832 }
52833
52834
52835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
52836   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52837   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52838
52839   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52840   arg2 = jarg2;
52841   {
52842     try {
52843       (arg1)->Remove(arg2);
52844     } catch (std::out_of_range& e) {
52845       {
52846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52847       };
52848     } catch (std::exception& e) {
52849       {
52850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52851       };
52852     } catch (Dali::DaliException e) {
52853       {
52854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52855       };
52856     } catch (...) {
52857       {
52858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52859       };
52860     }
52861   }
52862
52863
52864
52865 }
52866
52867
52868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52869   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52870   Dali::Vector< unsigned char > *arg2 = 0 ;
52871
52872   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52873   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52874   if (!arg2) {
52875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52876     return ;
52877   }
52878   {
52879     try {
52880       (arg1)->Swap(*arg2);
52881     } catch (std::out_of_range& e) {
52882       {
52883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52884       };
52885     } catch (std::exception& e) {
52886       {
52887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52888       };
52889     } catch (Dali::DaliException e) {
52890       {
52891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52892       };
52893     } catch (...) {
52894       {
52895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52896       };
52897     }
52898   }
52899
52900 }
52901
52902
52903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52904   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52905
52906   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52907   {
52908     try {
52909       (arg1)->Clear();
52910     } catch (std::out_of_range& e) {
52911       {
52912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52913       };
52914     } catch (std::exception& e) {
52915       {
52916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52917       };
52918     } catch (Dali::DaliException e) {
52919       {
52920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52921       };
52922     } catch (...) {
52923       {
52924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52925       };
52926     }
52927   }
52928
52929 }
52930
52931
52932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52933   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52934
52935   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52936   {
52937     try {
52938       (arg1)->Release();
52939     } catch (std::out_of_range& e) {
52940       {
52941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52942       };
52943     } catch (std::exception& e) {
52944       {
52945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52946       };
52947     } catch (Dali::DaliException e) {
52948       {
52949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52950       };
52951     } catch (...) {
52952       {
52953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52954       };
52955     }
52956   }
52957
52958 }
52959
52960
52961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52962   int jresult ;
52963   int result;
52964
52965   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52966   jresult = (int)result;
52967   return jresult;
52968 }
52969
52970
52971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52972   void * jresult ;
52973   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52974
52975   {
52976     try {
52977       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52978     } catch (std::out_of_range& e) {
52979       {
52980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52981       };
52982     } catch (std::exception& e) {
52983       {
52984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52985       };
52986     } catch (Dali::DaliException e) {
52987       {
52988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52989       };
52990     } catch (...) {
52991       {
52992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52993       };
52994     }
52995   }
52996
52997   jresult = (void *)result;
52998   return jresult;
52999 }
53000
53001
53002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
53003   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53004
53005   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53006   {
53007     try {
53008       delete arg1;
53009     } catch (std::out_of_range& e) {
53010       {
53011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53012       };
53013     } catch (std::exception& e) {
53014       {
53015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53016       };
53017     } catch (Dali::DaliException e) {
53018       {
53019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53020       };
53021     } catch (...) {
53022       {
53023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53024       };
53025     }
53026   }
53027
53028 }
53029
53030
53031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53032   void * jresult ;
53033   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53034   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53035
53036   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53037   if (!arg1) {
53038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53039     return 0;
53040   }
53041   {
53042     try {
53043       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53044     } catch (std::out_of_range& e) {
53045       {
53046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53047       };
53048     } catch (std::exception& e) {
53049       {
53050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53051       };
53052     } catch (Dali::DaliException e) {
53053       {
53054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53055       };
53056     } catch (...) {
53057       {
53058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53059       };
53060     }
53061   }
53062
53063   jresult = (void *)result;
53064   return jresult;
53065 }
53066
53067
53068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53069   void * jresult ;
53070   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53071   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53072   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53073
53074   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53075   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53076   if (!arg2) {
53077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53078     return 0;
53079   }
53080   {
53081     try {
53082       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
53083     } catch (std::out_of_range& e) {
53084       {
53085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53086       };
53087     } catch (std::exception& e) {
53088       {
53089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53090       };
53091     } catch (Dali::DaliException e) {
53092       {
53093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53094       };
53095     } catch (...) {
53096       {
53097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53098       };
53099     }
53100   }
53101
53102   jresult = (void *)result;
53103   return jresult;
53104 }
53105
53106
53107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
53108   void * jresult ;
53109   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53110   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53111
53112   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53113   {
53114     try {
53115       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53116     } catch (std::out_of_range& e) {
53117       {
53118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (std::exception& e) {
53121       {
53122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (Dali::DaliException e) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53127       };
53128     } catch (...) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53131       };
53132     }
53133   }
53134
53135   jresult = (void *)result;
53136   return jresult;
53137 }
53138
53139
53140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53141   void * jresult ;
53142   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53143   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53144
53145   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53146   {
53147     try {
53148       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53149     } catch (std::out_of_range& e) {
53150       {
53151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53152       };
53153     } catch (std::exception& e) {
53154       {
53155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (Dali::DaliException e) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167
53168   jresult = (void *)result;
53169   return jresult;
53170 }
53171
53172
53173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53174   void * jresult ;
53175   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53176   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53177   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53178
53179   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53180   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53181   {
53182     try {
53183       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53184     } catch (std::out_of_range& e) {
53185       {
53186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53187       };
53188     } catch (std::exception& e) {
53189       {
53190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53191       };
53192     } catch (Dali::DaliException e) {
53193       {
53194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53195       };
53196     } catch (...) {
53197       {
53198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53199       };
53200     }
53201   }
53202
53203   jresult = (void *)result;
53204   return jresult;
53205 }
53206
53207
53208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53209   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53210   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53211
53212   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53213   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53214   if (!arg2) {
53215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53216     return ;
53217   }
53218   {
53219     try {
53220       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53221     } catch (std::out_of_range& e) {
53222       {
53223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53224       };
53225     } catch (std::exception& e) {
53226       {
53227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53228       };
53229     } catch (Dali::DaliException e) {
53230       {
53231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53232       };
53233     } catch (...) {
53234       {
53235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53236       };
53237     }
53238   }
53239
53240 }
53241
53242
53243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53244   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53245   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53246   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53247
53248   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53249   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53250   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53251   if (!arg3) {
53252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53253     return ;
53254   }
53255   {
53256     try {
53257       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53258     } catch (std::out_of_range& e) {
53259       {
53260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (std::exception& e) {
53263       {
53264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53265       };
53266     } catch (Dali::DaliException e) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53269       };
53270     } catch (...) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53273       };
53274     }
53275   }
53276
53277 }
53278
53279
53280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53281   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53282   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53283   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53284   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53285
53286   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53287   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53288   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53289   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53290   {
53291     try {
53292       (arg1)->Insert(arg2,arg3,arg4);
53293     } catch (std::out_of_range& e) {
53294       {
53295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53296       };
53297     } catch (std::exception& e) {
53298       {
53299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53300       };
53301     } catch (Dali::DaliException e) {
53302       {
53303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53304       };
53305     } catch (...) {
53306       {
53307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53308       };
53309     }
53310   }
53311
53312 }
53313
53314
53315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53316   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53317   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53318
53319   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53320   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53321   {
53322     try {
53323       (arg1)->Reserve(arg2);
53324     } catch (std::out_of_range& e) {
53325       {
53326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53327       };
53328     } catch (std::exception& e) {
53329       {
53330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (Dali::DaliException e) {
53333       {
53334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53335       };
53336     } catch (...) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53339       };
53340     }
53341   }
53342
53343 }
53344
53345
53346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53347   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53348   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53349
53350   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53351   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53352   {
53353     try {
53354       (arg1)->Resize(arg2);
53355     } catch (std::out_of_range& e) {
53356       {
53357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53358       };
53359     } catch (std::exception& e) {
53360       {
53361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53362       };
53363     } catch (Dali::DaliException e) {
53364       {
53365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53366       };
53367     } catch (...) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53370       };
53371     }
53372   }
53373
53374 }
53375
53376
53377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53378   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53379   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53380   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53381
53382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53383   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53384   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53385   if (!arg3) {
53386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53387     return ;
53388   }
53389   {
53390     try {
53391       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53392     } catch (std::out_of_range& e) {
53393       {
53394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53395       };
53396     } catch (std::exception& e) {
53397       {
53398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53399       };
53400     } catch (Dali::DaliException e) {
53401       {
53402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53403       };
53404     } catch (...) {
53405       {
53406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53407       };
53408     }
53409   }
53410
53411 }
53412
53413
53414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53415   void * jresult ;
53416   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53417   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53418   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53419
53420   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53421   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53422   {
53423     try {
53424       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53425     } catch (std::out_of_range& e) {
53426       {
53427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53428       };
53429     } catch (std::exception& e) {
53430       {
53431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53432       };
53433     } catch (Dali::DaliException e) {
53434       {
53435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53436       };
53437     } catch (...) {
53438       {
53439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53440       };
53441     }
53442   }
53443
53444   jresult = (void *)result;
53445   return jresult;
53446 }
53447
53448
53449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53450   void * jresult ;
53451   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53452   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53453   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53454   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53455
53456   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53457   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53458   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53459   {
53460     try {
53461       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53462     } catch (std::out_of_range& e) {
53463       {
53464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53465       };
53466     } catch (std::exception& e) {
53467       {
53468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53469       };
53470     } catch (Dali::DaliException e) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53473       };
53474     } catch (...) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53477       };
53478     }
53479   }
53480
53481   jresult = (void *)result;
53482   return jresult;
53483 }
53484
53485
53486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53487   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53488   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53489
53490   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53491   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53492   {
53493     try {
53494       (arg1)->Remove(arg2);
53495     } catch (std::out_of_range& e) {
53496       {
53497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53498       };
53499     } catch (std::exception& e) {
53500       {
53501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53502       };
53503     } catch (Dali::DaliException e) {
53504       {
53505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53506       };
53507     } catch (...) {
53508       {
53509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53510       };
53511     }
53512   }
53513
53514 }
53515
53516
53517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53518   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53519   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53520
53521   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53522   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53523   if (!arg2) {
53524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53525     return ;
53526   }
53527   {
53528     try {
53529       (arg1)->Swap(*arg2);
53530     } catch (std::out_of_range& e) {
53531       {
53532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53533       };
53534     } catch (std::exception& e) {
53535       {
53536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53537       };
53538     } catch (Dali::DaliException e) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53541       };
53542     } catch (...) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53545       };
53546     }
53547   }
53548
53549 }
53550
53551
53552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53553   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53554
53555   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53556   {
53557     try {
53558       (arg1)->Clear();
53559     } catch (std::out_of_range& e) {
53560       {
53561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53562       };
53563     } catch (std::exception& e) {
53564       {
53565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53566       };
53567     } catch (Dali::DaliException e) {
53568       {
53569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53570       };
53571     } catch (...) {
53572       {
53573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53574       };
53575     }
53576   }
53577
53578 }
53579
53580
53581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53582   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53583
53584   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53585   {
53586     try {
53587       (arg1)->Release();
53588     } catch (std::out_of_range& e) {
53589       {
53590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53591       };
53592     } catch (std::exception& e) {
53593       {
53594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53595       };
53596     } catch (Dali::DaliException e) {
53597       {
53598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53599       };
53600     } catch (...) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53603       };
53604     }
53605   }
53606
53607 }
53608
53609
53610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53611   void * jresult ;
53612   Dali::Signal< void () > *result = 0 ;
53613
53614   {
53615     try {
53616       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53617     } catch (std::out_of_range& e) {
53618       {
53619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53620       };
53621     } catch (std::exception& e) {
53622       {
53623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53624       };
53625     } catch (Dali::DaliException e) {
53626       {
53627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53628       };
53629     } catch (...) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53632       };
53633     }
53634   }
53635
53636   jresult = (void *)result;
53637   return jresult;
53638 }
53639
53640
53641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53642   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53643
53644   arg1 = (Dali::Signal< void () > *)jarg1;
53645   {
53646     try {
53647       delete arg1;
53648     } catch (std::out_of_range& e) {
53649       {
53650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53651       };
53652     } catch (std::exception& e) {
53653       {
53654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53655       };
53656     } catch (Dali::DaliException e) {
53657       {
53658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53659       };
53660     } catch (...) {
53661       {
53662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53663       };
53664     }
53665   }
53666
53667 }
53668
53669
53670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53671   unsigned int jresult ;
53672   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53673   bool result;
53674
53675   arg1 = (Dali::Signal< void () > *)jarg1;
53676   {
53677     try {
53678       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53679     } catch (std::out_of_range& e) {
53680       {
53681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53682       };
53683     } catch (std::exception& e) {
53684       {
53685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53686       };
53687     } catch (Dali::DaliException e) {
53688       {
53689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53690       };
53691     } catch (...) {
53692       {
53693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53694       };
53695     }
53696   }
53697
53698   jresult = result;
53699   return jresult;
53700 }
53701
53702
53703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53704   unsigned long jresult ;
53705   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53706   std::size_t result;
53707
53708   arg1 = (Dali::Signal< void () > *)jarg1;
53709   {
53710     try {
53711       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53712     } catch (std::out_of_range& e) {
53713       {
53714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53715       };
53716     } catch (std::exception& e) {
53717       {
53718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53719       };
53720     } catch (Dali::DaliException e) {
53721       {
53722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53723       };
53724     } catch (...) {
53725       {
53726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53727       };
53728     }
53729   }
53730
53731   jresult = (unsigned long)result;
53732   return jresult;
53733 }
53734
53735
53736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53737   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53738   void (*arg2)() = (void (*)()) 0 ;
53739
53740   arg1 = (Dali::Signal< void () > *)jarg1;
53741   arg2 = (void (*)())jarg2;
53742   {
53743     try {
53744       (arg1)->Connect(arg2);
53745     } catch (std::out_of_range& e) {
53746       {
53747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53748       };
53749     } catch (std::exception& e) {
53750       {
53751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53752       };
53753     } catch (Dali::DaliException e) {
53754       {
53755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53756       };
53757     } catch (...) {
53758       {
53759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53760       };
53761     }
53762   }
53763
53764 }
53765
53766
53767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53768   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53769   void (*arg2)() = (void (*)()) 0 ;
53770
53771   arg1 = (Dali::Signal< void () > *)jarg1;
53772   arg2 = (void (*)())jarg2;
53773   {
53774     try {
53775       (arg1)->Disconnect(arg2);
53776     } catch (std::out_of_range& e) {
53777       {
53778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53779       };
53780     } catch (std::exception& e) {
53781       {
53782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53783       };
53784     } catch (Dali::DaliException e) {
53785       {
53786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53787       };
53788     } catch (...) {
53789       {
53790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53791       };
53792     }
53793   }
53794
53795 }
53796
53797
53798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53799   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53800   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53801   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53802
53803   arg1 = (Dali::Signal< void () > *)jarg1;
53804   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53805   arg3 = (Dali::FunctorDelegate *)jarg3;
53806   {
53807     try {
53808       (arg1)->Connect(arg2,arg3);
53809     } catch (std::out_of_range& e) {
53810       {
53811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53812       };
53813     } catch (std::exception& e) {
53814       {
53815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53816       };
53817     } catch (Dali::DaliException e) {
53818       {
53819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53820       };
53821     } catch (...) {
53822       {
53823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53824       };
53825     }
53826   }
53827
53828 }
53829
53830
53831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53832   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53833
53834   arg1 = (Dali::Signal< void () > *)jarg1;
53835   {
53836     try {
53837       (arg1)->Emit();
53838     } catch (std::out_of_range& e) {
53839       {
53840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53841       };
53842     } catch (std::exception& e) {
53843       {
53844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53845       };
53846     } catch (Dali::DaliException e) {
53847       {
53848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53849       };
53850     } catch (...) {
53851       {
53852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53853       };
53854     }
53855   }
53856
53857 }
53858
53859
53860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53861   unsigned int jresult ;
53862   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53863   bool result;
53864
53865   arg1 = (Dali::Signal< void (float) > *)jarg1;
53866   {
53867     try {
53868       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53869     } catch (std::out_of_range& e) {
53870       {
53871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53872       };
53873     } catch (std::exception& e) {
53874       {
53875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53876       };
53877     } catch (Dali::DaliException e) {
53878       {
53879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53880       };
53881     } catch (...) {
53882       {
53883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53884       };
53885     }
53886   }
53887
53888   jresult = result;
53889   return jresult;
53890 }
53891
53892
53893 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53894   unsigned long jresult ;
53895   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53896   std::size_t result;
53897
53898   arg1 = (Dali::Signal< void (float) > *)jarg1;
53899   {
53900     try {
53901       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53902     } catch (std::out_of_range& e) {
53903       {
53904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53905       };
53906     } catch (std::exception& e) {
53907       {
53908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53909       };
53910     } catch (Dali::DaliException e) {
53911       {
53912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53913       };
53914     } catch (...) {
53915       {
53916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53917       };
53918     }
53919   }
53920
53921   jresult = (unsigned long)result;
53922   return jresult;
53923 }
53924
53925
53926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53927   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53928   void (*arg2)(float) = (void (*)(float)) 0 ;
53929
53930   arg1 = (Dali::Signal< void (float) > *)jarg1;
53931   arg2 = (void (*)(float))jarg2;
53932   {
53933     try {
53934       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53935     } catch (std::out_of_range& e) {
53936       {
53937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53938       };
53939     } catch (std::exception& e) {
53940       {
53941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53942       };
53943     } catch (Dali::DaliException e) {
53944       {
53945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53946       };
53947     } catch (...) {
53948       {
53949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53950       };
53951     }
53952   }
53953
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53958   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53959   void (*arg2)(float) = (void (*)(float)) 0 ;
53960
53961   arg1 = (Dali::Signal< void (float) > *)jarg1;
53962   arg2 = (void (*)(float))jarg2;
53963   {
53964     try {
53965       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53966     } catch (std::out_of_range& e) {
53967       {
53968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (std::exception& e) {
53971       {
53972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53973       };
53974     } catch (Dali::DaliException e) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53977       };
53978     } catch (...) {
53979       {
53980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53981       };
53982     }
53983   }
53984
53985 }
53986
53987
53988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53989   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53990   float arg2 ;
53991
53992   arg1 = (Dali::Signal< void (float) > *)jarg1;
53993   arg2 = (float)jarg2;
53994   {
53995     try {
53996       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53997     } catch (std::out_of_range& e) {
53998       {
53999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (std::exception& e) {
54002       {
54003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54004       };
54005     } catch (Dali::DaliException e) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54008       };
54009     } catch (...) {
54010       {
54011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54012       };
54013     }
54014   }
54015
54016 }
54017
54018
54019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54020   void * jresult ;
54021   Dali::Signal< void (float) > *result = 0 ;
54022
54023   {
54024     try {
54025       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54026     } catch (std::out_of_range& e) {
54027       {
54028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54029       };
54030     } catch (std::exception& e) {
54031       {
54032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54033       };
54034     } catch (Dali::DaliException e) {
54035       {
54036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54037       };
54038     } catch (...) {
54039       {
54040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54041       };
54042     }
54043   }
54044
54045   jresult = (void *)result;
54046   return jresult;
54047 }
54048
54049
54050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54051   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54052
54053   arg1 = (Dali::Signal< void (float) > *)jarg1;
54054   {
54055     try {
54056       delete arg1;
54057     } catch (std::out_of_range& e) {
54058       {
54059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54060       };
54061     } catch (std::exception& e) {
54062       {
54063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (Dali::DaliException e) {
54066       {
54067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54068       };
54069     } catch (...) {
54070       {
54071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54072       };
54073     }
54074   }
54075
54076 }
54077
54078
54079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54080   unsigned int jresult ;
54081   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54082   bool result;
54083
54084   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54085   {
54086     try {
54087       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54088     } catch (std::out_of_range& e) {
54089       {
54090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54091       };
54092     } catch (std::exception& e) {
54093       {
54094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (Dali::DaliException e) {
54097       {
54098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54099       };
54100     } catch (...) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54103       };
54104     }
54105   }
54106
54107   jresult = result;
54108   return jresult;
54109 }
54110
54111
54112 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54113   unsigned long jresult ;
54114   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54115   std::size_t result;
54116
54117   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54118   {
54119     try {
54120       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54121     } catch (std::out_of_range& e) {
54122       {
54123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54124       };
54125     } catch (std::exception& e) {
54126       {
54127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54128       };
54129     } catch (Dali::DaliException e) {
54130       {
54131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54132       };
54133     } catch (...) {
54134       {
54135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54136       };
54137     }
54138   }
54139
54140   jresult = (unsigned long)result;
54141   return jresult;
54142 }
54143
54144
54145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54146   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54147   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54148
54149   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54150   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54151   {
54152     try {
54153       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54154     } catch (std::out_of_range& e) {
54155       {
54156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54157       };
54158     } catch (std::exception& e) {
54159       {
54160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54161       };
54162     } catch (Dali::DaliException e) {
54163       {
54164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54165       };
54166     } catch (...) {
54167       {
54168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54169       };
54170     }
54171   }
54172
54173 }
54174
54175
54176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54177   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54178   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54179
54180   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54181   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54182   {
54183     try {
54184       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54185     } catch (std::out_of_range& e) {
54186       {
54187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54188       };
54189     } catch (std::exception& e) {
54190       {
54191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54192       };
54193     } catch (Dali::DaliException e) {
54194       {
54195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54196       };
54197     } catch (...) {
54198       {
54199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54200       };
54201     }
54202   }
54203
54204 }
54205
54206
54207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54208   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54209   Dali::BaseHandle arg2 ;
54210   Dali::BaseHandle *argp2 ;
54211
54212   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54213   argp2 = (Dali::BaseHandle *)jarg2;
54214   if (!argp2) {
54215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54216     return ;
54217   }
54218   arg2 = *argp2;
54219   {
54220     try {
54221       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54222     } catch (std::out_of_range& e) {
54223       {
54224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54225       };
54226     } catch (std::exception& e) {
54227       {
54228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54229       };
54230     } catch (Dali::DaliException e) {
54231       {
54232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54233       };
54234     } catch (...) {
54235       {
54236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54237       };
54238     }
54239   }
54240
54241 }
54242
54243
54244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54245   void * jresult ;
54246   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54247
54248   {
54249     try {
54250       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54251     } catch (std::out_of_range& e) {
54252       {
54253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (std::exception& e) {
54256       {
54257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (Dali::DaliException e) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54262       };
54263     } catch (...) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54266       };
54267     }
54268   }
54269
54270   jresult = (void *)result;
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54276   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54277
54278   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54279   {
54280     try {
54281       delete arg1;
54282     } catch (std::out_of_range& e) {
54283       {
54284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (std::exception& e) {
54287       {
54288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54289       };
54290     } catch (Dali::DaliException e) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54293       };
54294     } catch (...) {
54295       {
54296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54297       };
54298     }
54299   }
54300
54301 }
54302
54303
54304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54305   unsigned int jresult ;
54306   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54307   bool result;
54308
54309   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54310   {
54311     try {
54312       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54313     } catch (std::out_of_range& e) {
54314       {
54315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (std::exception& e) {
54318       {
54319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54320       };
54321     } catch (Dali::DaliException e) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54324       };
54325     } catch (...) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54328       };
54329     }
54330   }
54331
54332   jresult = result;
54333   return jresult;
54334 }
54335
54336
54337 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54338   unsigned long jresult ;
54339   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54340   std::size_t result;
54341
54342   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54343   {
54344     try {
54345       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54346     } catch (std::out_of_range& e) {
54347       {
54348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (std::exception& e) {
54351       {
54352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54353       };
54354     } catch (Dali::DaliException e) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54357       };
54358     } catch (...) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54361       };
54362     }
54363   }
54364
54365   jresult = (unsigned long)result;
54366   return jresult;
54367 }
54368
54369
54370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54371   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54372   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54373
54374   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54375   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54376   {
54377     try {
54378       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54386       };
54387     } catch (Dali::DaliException e) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54390       };
54391     } catch (...) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54394       };
54395     }
54396   }
54397
54398 }
54399
54400
54401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54403   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54404
54405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54406   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54407   {
54408     try {
54409       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54410     } catch (std::out_of_range& e) {
54411       {
54412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (std::exception& e) {
54415       {
54416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54417       };
54418     } catch (Dali::DaliException e) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54421       };
54422     } catch (...) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54425       };
54426     }
54427   }
54428
54429 }
54430
54431
54432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54433   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54434   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54435
54436   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54437   arg2 = (Dali::RefObject *)jarg2;
54438   {
54439     try {
54440       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54441     } catch (std::out_of_range& e) {
54442       {
54443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54444       };
54445     } catch (std::exception& e) {
54446       {
54447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54448       };
54449     } catch (Dali::DaliException e) {
54450       {
54451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54452       };
54453     } catch (...) {
54454       {
54455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54456       };
54457     }
54458   }
54459
54460 }
54461
54462
54463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54464   void * jresult ;
54465   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54466
54467   {
54468     try {
54469       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54470     } catch (std::out_of_range& e) {
54471       {
54472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54473       };
54474     } catch (std::exception& e) {
54475       {
54476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54477       };
54478     } catch (Dali::DaliException e) {
54479       {
54480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54481       };
54482     } catch (...) {
54483       {
54484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54485       };
54486     }
54487   }
54488
54489   jresult = (void *)result;
54490   return jresult;
54491 }
54492
54493
54494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54495   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54496
54497   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54498   {
54499     try {
54500       delete arg1;
54501     } catch (std::out_of_range& e) {
54502       {
54503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54504       };
54505     } catch (std::exception& e) {
54506       {
54507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54508       };
54509     } catch (Dali::DaliException e) {
54510       {
54511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54512       };
54513     } catch (...) {
54514       {
54515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54516       };
54517     }
54518   }
54519
54520 }
54521
54522
54523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54524   unsigned int jresult ;
54525   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54526   bool result;
54527
54528   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54529   {
54530     try {
54531       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54532     } catch (std::out_of_range& e) {
54533       {
54534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54535       };
54536     } catch (std::exception& e) {
54537       {
54538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54539       };
54540     } catch (Dali::DaliException e) {
54541       {
54542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54543       };
54544     } catch (...) {
54545       {
54546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54547       };
54548     }
54549   }
54550
54551   jresult = result;
54552   return jresult;
54553 }
54554
54555
54556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54557   unsigned long jresult ;
54558   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54559   std::size_t result;
54560
54561   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54562   {
54563     try {
54564       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54565     } catch (std::out_of_range& e) {
54566       {
54567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54568       };
54569     } catch (std::exception& e) {
54570       {
54571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54572       };
54573     } catch (Dali::DaliException e) {
54574       {
54575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54576       };
54577     } catch (...) {
54578       {
54579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54580       };
54581     }
54582   }
54583
54584   jresult = (unsigned long)result;
54585   return jresult;
54586 }
54587
54588
54589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54590   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54591   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54592
54593   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54594   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54595   {
54596     try {
54597       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54598     } catch (std::out_of_range& e) {
54599       {
54600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54601       };
54602     } catch (std::exception& e) {
54603       {
54604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54605       };
54606     } catch (Dali::DaliException e) {
54607       {
54608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54609       };
54610     } catch (...) {
54611       {
54612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54613       };
54614     }
54615   }
54616
54617 }
54618
54619
54620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54621   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54622   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54623
54624   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54625   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54626   {
54627     try {
54628       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54629     } catch (std::out_of_range& e) {
54630       {
54631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54632       };
54633     } catch (std::exception& e) {
54634       {
54635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54636       };
54637     } catch (Dali::DaliException e) {
54638       {
54639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54640       };
54641     } catch (...) {
54642       {
54643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54644       };
54645     }
54646   }
54647
54648 }
54649
54650
54651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54652   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54653   Dali::PropertyNotification *arg2 = 0 ;
54654
54655   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54656   arg2 = (Dali::PropertyNotification *)jarg2;
54657   if (!arg2) {
54658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54659     return ;
54660   }
54661   {
54662     try {
54663       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54664     } catch (std::out_of_range& e) {
54665       {
54666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54667       };
54668     } catch (std::exception& e) {
54669       {
54670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54671       };
54672     } catch (Dali::DaliException e) {
54673       {
54674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54675       };
54676     } catch (...) {
54677       {
54678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54679       };
54680     }
54681   }
54682
54683 }
54684
54685
54686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54687   void * jresult ;
54688   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54689
54690   {
54691     try {
54692       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54693     } catch (std::out_of_range& e) {
54694       {
54695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54696       };
54697     } catch (std::exception& e) {
54698       {
54699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54700       };
54701     } catch (Dali::DaliException e) {
54702       {
54703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54704       };
54705     } catch (...) {
54706       {
54707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54708       };
54709     }
54710   }
54711
54712   jresult = (void *)result;
54713   return jresult;
54714 }
54715
54716
54717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54718   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54719
54720   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54721   {
54722     try {
54723       delete arg1;
54724     } catch (std::out_of_range& e) {
54725       {
54726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54727       };
54728     } catch (std::exception& e) {
54729       {
54730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54731       };
54732     } catch (Dali::DaliException e) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54735       };
54736     } catch (...) {
54737       {
54738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54739       };
54740     }
54741   }
54742
54743 }
54744
54745
54746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54747   unsigned int jresult ;
54748   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54749   bool result;
54750
54751   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54752   {
54753     try {
54754       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54755     } catch (std::out_of_range& e) {
54756       {
54757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54758       };
54759     } catch (std::exception& e) {
54760       {
54761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54762       };
54763     } catch (Dali::DaliException e) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54766       };
54767     } catch (...) {
54768       {
54769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54770       };
54771     }
54772   }
54773
54774   jresult = result;
54775   return jresult;
54776 }
54777
54778
54779 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54780   unsigned long jresult ;
54781   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54782   std::size_t result;
54783
54784   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54785   {
54786     try {
54787       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (Dali::DaliException e) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54803       };
54804     }
54805   }
54806
54807   jresult = (unsigned long)result;
54808   return jresult;
54809 }
54810
54811
54812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54813   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54814   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54815
54816   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54817   arg2 = (void (*)(Dali::Image))jarg2;
54818   {
54819     try {
54820       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54821     } catch (std::out_of_range& e) {
54822       {
54823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54824       };
54825     } catch (std::exception& e) {
54826       {
54827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54828       };
54829     } catch (Dali::DaliException e) {
54830       {
54831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54832       };
54833     } catch (...) {
54834       {
54835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54836       };
54837     }
54838   }
54839
54840 }
54841
54842
54843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54844   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54845   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54846
54847   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54848   arg2 = (void (*)(Dali::Image))jarg2;
54849   {
54850     try {
54851       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54852     } catch (std::out_of_range& e) {
54853       {
54854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54855       };
54856     } catch (std::exception& e) {
54857       {
54858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54859       };
54860     } catch (Dali::DaliException e) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54863       };
54864     } catch (...) {
54865       {
54866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54867       };
54868     }
54869   }
54870
54871 }
54872
54873
54874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54875   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54876   Dali::Image arg2 ;
54877   Dali::Image *argp2 ;
54878
54879   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54880   argp2 = (Dali::Image *)jarg2;
54881   if (!argp2) {
54882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54883     return ;
54884   }
54885   arg2 = *argp2;
54886   {
54887     try {
54888       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54889     } catch (std::out_of_range& e) {
54890       {
54891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (std::exception& e) {
54894       {
54895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54896       };
54897     } catch (Dali::DaliException e) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54900       };
54901     } catch (...) {
54902       {
54903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54904       };
54905     }
54906   }
54907
54908 }
54909
54910
54911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54912   void * jresult ;
54913   Dali::Signal< void (Dali::Image) > *result = 0 ;
54914
54915   {
54916     try {
54917       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54918     } catch (std::out_of_range& e) {
54919       {
54920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (std::exception& e) {
54923       {
54924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54925       };
54926     } catch (Dali::DaliException e) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54929       };
54930     } catch (...) {
54931       {
54932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54933       };
54934     }
54935   }
54936
54937   jresult = (void *)result;
54938   return jresult;
54939 }
54940
54941
54942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54943   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54944
54945   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54946   {
54947     try {
54948       delete arg1;
54949     } catch (std::out_of_range& e) {
54950       {
54951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (std::exception& e) {
54954       {
54955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54956       };
54957     } catch (Dali::DaliException e) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54960       };
54961     } catch (...) {
54962       {
54963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54964       };
54965     }
54966   }
54967
54968 }
54969
54970
54971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54972   void * jresult ;
54973   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54974
54975   {
54976     try {
54977       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54978     } catch (std::out_of_range& e) {
54979       {
54980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (std::exception& e) {
54983       {
54984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54985       };
54986     } catch (Dali::DaliException e) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54989       };
54990     } catch (...) {
54991       {
54992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54993       };
54994     }
54995   }
54996
54997   jresult = (void *)result;
54998   return jresult;
54999 }
55000
55001
55002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
55003   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
55004
55005   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55006   {
55007     try {
55008       delete arg1;
55009     } catch (std::out_of_range& e) {
55010       {
55011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55012       };
55013     } catch (std::exception& e) {
55014       {
55015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55016       };
55017     } catch (Dali::DaliException e) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55020       };
55021     } catch (...) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55024       };
55025     }
55026   }
55027
55028 }
55029
55030
55031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55032   unsigned int jresult ;
55033   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55034   bool result;
55035
55036   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55037   {
55038     try {
55039       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);
55040     } catch (std::out_of_range& e) {
55041       {
55042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55043       };
55044     } catch (std::exception& e) {
55045       {
55046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (Dali::DaliException e) {
55049       {
55050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55051       };
55052     } catch (...) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55055       };
55056     }
55057   }
55058
55059   jresult = result;
55060   return jresult;
55061 }
55062
55063
55064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55065   unsigned long jresult ;
55066   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55067   std::size_t result;
55068
55069   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55070   {
55071     try {
55072       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);
55073     } catch (std::out_of_range& e) {
55074       {
55075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55076       };
55077     } catch (std::exception& e) {
55078       {
55079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55080       };
55081     } catch (Dali::DaliException e) {
55082       {
55083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55084       };
55085     } catch (...) {
55086       {
55087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55088       };
55089     }
55090   }
55091
55092   jresult = (unsigned long)result;
55093   return jresult;
55094 }
55095
55096
55097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55098   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55099   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55100
55101   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55102   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55103   {
55104     try {
55105       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55106     } catch (std::out_of_range& e) {
55107       {
55108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55109       };
55110     } catch (std::exception& e) {
55111       {
55112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (Dali::DaliException e) {
55115       {
55116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55117       };
55118     } catch (...) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55121       };
55122     }
55123   }
55124
55125 }
55126
55127
55128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55129   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55130   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55131
55132   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55133   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55134   {
55135     try {
55136       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55137     } catch (std::out_of_range& e) {
55138       {
55139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55140       };
55141     } catch (std::exception& e) {
55142       {
55143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55144       };
55145     } catch (Dali::DaliException e) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55148       };
55149     } catch (...) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55152       };
55153     }
55154   }
55155
55156 }
55157
55158
55159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55160   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55161   Dali::Actor arg2 ;
55162   Dali::LongPressGesture *arg3 = 0 ;
55163   Dali::Actor *argp2 ;
55164
55165   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55166   argp2 = (Dali::Actor *)jarg2;
55167   if (!argp2) {
55168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55169     return ;
55170   }
55171   arg2 = *argp2;
55172   arg3 = (Dali::LongPressGesture *)jarg3;
55173   if (!arg3) {
55174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55175     return ;
55176   }
55177   {
55178     try {
55179       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
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_new_LongPressGestureDetectedSignal() {
55203   void * jresult ;
55204   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55205
55206   {
55207     try {
55208       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55209     } catch (std::out_of_range& e) {
55210       {
55211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55212       };
55213     } catch (std::exception& e) {
55214       {
55215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55216       };
55217     } catch (Dali::DaliException e) {
55218       {
55219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55220       };
55221     } catch (...) {
55222       {
55223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55224       };
55225     }
55226   }
55227
55228   jresult = (void *)result;
55229   return jresult;
55230 }
55231
55232
55233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55234   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55235
55236   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55237   {
55238     try {
55239       delete arg1;
55240     } catch (std::out_of_range& e) {
55241       {
55242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55243       };
55244     } catch (std::exception& e) {
55245       {
55246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55247       };
55248     } catch (Dali::DaliException e) {
55249       {
55250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55251       };
55252     } catch (...) {
55253       {
55254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55255       };
55256     }
55257   }
55258
55259 }
55260
55261
55262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55263   unsigned int jresult ;
55264   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55265   bool result;
55266
55267   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55268   {
55269     try {
55270       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);
55271     } catch (std::out_of_range& e) {
55272       {
55273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55274       };
55275     } catch (std::exception& e) {
55276       {
55277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55278       };
55279     } catch (Dali::DaliException e) {
55280       {
55281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55282       };
55283     } catch (...) {
55284       {
55285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55286       };
55287     }
55288   }
55289
55290   jresult = result;
55291   return jresult;
55292 }
55293
55294
55295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55296   unsigned long jresult ;
55297   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55298   std::size_t result;
55299
55300   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55301   {
55302     try {
55303       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);
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (Dali::DaliException e) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55315       };
55316     } catch (...) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55319       };
55320     }
55321   }
55322
55323   jresult = (unsigned long)result;
55324   return jresult;
55325 }
55326
55327
55328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55329   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55330   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55331
55332   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55333   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55334   {
55335     try {
55336       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55337     } catch (std::out_of_range& e) {
55338       {
55339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55340       };
55341     } catch (std::exception& e) {
55342       {
55343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55344       };
55345     } catch (Dali::DaliException e) {
55346       {
55347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55348       };
55349     } catch (...) {
55350       {
55351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55352       };
55353     }
55354   }
55355
55356 }
55357
55358
55359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55360   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55361   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55362
55363   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55364   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55365   {
55366     try {
55367       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55368     } catch (std::out_of_range& e) {
55369       {
55370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55371       };
55372     } catch (std::exception& e) {
55373       {
55374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55375       };
55376     } catch (Dali::DaliException e) {
55377       {
55378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55379       };
55380     } catch (...) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55383       };
55384     }
55385   }
55386
55387 }
55388
55389
55390 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55391   unsigned int jresult ;
55392   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55393   Dali::Actor arg2 ;
55394   Dali::TouchData *arg3 = 0 ;
55395   Dali::Actor *argp2 ;
55396   bool result;
55397
55398   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55399   argp2 = (Dali::Actor *)jarg2;
55400   if (!argp2) {
55401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55402     return 0;
55403   }
55404   arg2 = *argp2;
55405   arg3 = (Dali::TouchData *)jarg3;
55406   if (!arg3) {
55407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55408     return 0;
55409   }
55410   {
55411     try {
55412       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55413     } catch (std::out_of_range& e) {
55414       {
55415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55416       };
55417     } catch (std::exception& e) {
55418       {
55419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55420       };
55421     } catch (Dali::DaliException e) {
55422       {
55423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55424       };
55425     } catch (...) {
55426       {
55427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55428       };
55429     }
55430   }
55431
55432   jresult = result;
55433   return jresult;
55434 }
55435
55436
55437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55438   void * jresult ;
55439   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55440
55441   {
55442     try {
55443       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55444     } catch (std::out_of_range& e) {
55445       {
55446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55447       };
55448     } catch (std::exception& e) {
55449       {
55450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55451       };
55452     } catch (Dali::DaliException e) {
55453       {
55454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55455       };
55456     } catch (...) {
55457       {
55458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55459       };
55460     }
55461   }
55462
55463   jresult = (void *)result;
55464   return jresult;
55465 }
55466
55467
55468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55469   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55470
55471   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55472   {
55473     try {
55474       delete arg1;
55475     } catch (std::out_of_range& e) {
55476       {
55477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55478       };
55479     } catch (std::exception& e) {
55480       {
55481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55482       };
55483     } catch (Dali::DaliException e) {
55484       {
55485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55486       };
55487     } catch (...) {
55488       {
55489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55490       };
55491     }
55492   }
55493
55494 }
55495
55496
55497 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55498   unsigned int jresult ;
55499   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55500   bool result;
55501
55502   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55503   {
55504     try {
55505       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);
55506     } catch (std::out_of_range& e) {
55507       {
55508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55509       };
55510     } catch (std::exception& e) {
55511       {
55512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55513       };
55514     } catch (Dali::DaliException e) {
55515       {
55516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55517       };
55518     } catch (...) {
55519       {
55520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55521       };
55522     }
55523   }
55524
55525   jresult = result;
55526   return jresult;
55527 }
55528
55529
55530 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55531   unsigned long jresult ;
55532   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55533   std::size_t result;
55534
55535   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55536   {
55537     try {
55538       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);
55539     } catch (std::out_of_range& e) {
55540       {
55541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55542       };
55543     } catch (std::exception& e) {
55544       {
55545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55546       };
55547     } catch (Dali::DaliException e) {
55548       {
55549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55550       };
55551     } catch (...) {
55552       {
55553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55554       };
55555     }
55556   }
55557
55558   jresult = (unsigned long)result;
55559   return jresult;
55560 }
55561
55562
55563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55564   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55565   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55566
55567   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55568   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55569   {
55570     try {
55571       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55572     } catch (std::out_of_range& e) {
55573       {
55574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55575       };
55576     } catch (std::exception& e) {
55577       {
55578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55579       };
55580     } catch (Dali::DaliException e) {
55581       {
55582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55583       };
55584     } catch (...) {
55585       {
55586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55587       };
55588     }
55589   }
55590
55591 }
55592
55593
55594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55595   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55596   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55597
55598   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55599   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55600   {
55601     try {
55602       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55603     } catch (std::out_of_range& e) {
55604       {
55605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55606       };
55607     } catch (std::exception& e) {
55608       {
55609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55610       };
55611     } catch (Dali::DaliException e) {
55612       {
55613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55614       };
55615     } catch (...) {
55616       {
55617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55618       };
55619     }
55620   }
55621
55622 }
55623
55624
55625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55626   unsigned int jresult ;
55627   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55628   Dali::Actor arg2 ;
55629   Dali::HoverEvent *arg3 = 0 ;
55630   Dali::Actor *argp2 ;
55631   bool result;
55632
55633   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55634   argp2 = (Dali::Actor *)jarg2;
55635   if (!argp2) {
55636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55637     return 0;
55638   }
55639   arg2 = *argp2;
55640   arg3 = (Dali::HoverEvent *)jarg3;
55641   if (!arg3) {
55642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55643     return 0;
55644   }
55645   {
55646     try {
55647       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55648     } catch (std::out_of_range& e) {
55649       {
55650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55651       };
55652     } catch (std::exception& e) {
55653       {
55654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55655       };
55656     } catch (Dali::DaliException e) {
55657       {
55658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55659       };
55660     } catch (...) {
55661       {
55662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55663       };
55664     }
55665   }
55666
55667   jresult = result;
55668   return jresult;
55669 }
55670
55671
55672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55673   void * jresult ;
55674   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55675
55676   {
55677     try {
55678       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55679     } catch (std::out_of_range& e) {
55680       {
55681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (std::exception& e) {
55684       {
55685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55686       };
55687     } catch (Dali::DaliException e) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55690       };
55691     } catch (...) {
55692       {
55693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55694       };
55695     }
55696   }
55697
55698   jresult = (void *)result;
55699   return jresult;
55700 }
55701
55702
55703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55704   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55705
55706   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55707   {
55708     try {
55709       delete arg1;
55710     } catch (std::out_of_range& e) {
55711       {
55712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55713       };
55714     } catch (std::exception& e) {
55715       {
55716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55717       };
55718     } catch (Dali::DaliException e) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55721       };
55722     } catch (...) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55725       };
55726     }
55727   }
55728
55729 }
55730
55731
55732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55733   unsigned int jresult ;
55734   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55735   bool result;
55736
55737   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55738   {
55739     try {
55740       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);
55741     } catch (std::out_of_range& e) {
55742       {
55743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55744       };
55745     } catch (std::exception& e) {
55746       {
55747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (Dali::DaliException e) {
55750       {
55751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55752       };
55753     } catch (...) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55756       };
55757     }
55758   }
55759
55760   jresult = result;
55761   return jresult;
55762 }
55763
55764
55765 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55766   unsigned long jresult ;
55767   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55768   std::size_t result;
55769
55770   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55771   {
55772     try {
55773       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);
55774     } catch (std::out_of_range& e) {
55775       {
55776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55777       };
55778     } catch (std::exception& e) {
55779       {
55780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55781       };
55782     } catch (Dali::DaliException e) {
55783       {
55784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55785       };
55786     } catch (...) {
55787       {
55788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55789       };
55790     }
55791   }
55792
55793   jresult = (unsigned long)result;
55794   return jresult;
55795 }
55796
55797
55798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55799   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55800   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55801
55802   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55803   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55804   {
55805     try {
55806       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55807     } catch (std::out_of_range& e) {
55808       {
55809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55810       };
55811     } catch (std::exception& e) {
55812       {
55813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55814       };
55815     } catch (Dali::DaliException e) {
55816       {
55817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55818       };
55819     } catch (...) {
55820       {
55821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55822       };
55823     }
55824   }
55825
55826 }
55827
55828
55829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55830   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55831   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55832
55833   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55834   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55835   {
55836     try {
55837       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55838     } catch (std::out_of_range& e) {
55839       {
55840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55841       };
55842     } catch (std::exception& e) {
55843       {
55844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55845       };
55846     } catch (Dali::DaliException e) {
55847       {
55848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55849       };
55850     } catch (...) {
55851       {
55852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55853       };
55854     }
55855   }
55856
55857 }
55858
55859
55860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55861   unsigned int jresult ;
55862   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55863   Dali::Actor arg2 ;
55864   Dali::WheelEvent *arg3 = 0 ;
55865   Dali::Actor *argp2 ;
55866   bool result;
55867
55868   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55869   argp2 = (Dali::Actor *)jarg2;
55870   if (!argp2) {
55871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55872     return 0;
55873   }
55874   arg2 = *argp2;
55875   arg3 = (Dali::WheelEvent *)jarg3;
55876   if (!arg3) {
55877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55878     return 0;
55879   }
55880   {
55881     try {
55882       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55883     } catch (std::out_of_range& e) {
55884       {
55885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55886       };
55887     } catch (std::exception& e) {
55888       {
55889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55890       };
55891     } catch (Dali::DaliException e) {
55892       {
55893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55894       };
55895     } catch (...) {
55896       {
55897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55898       };
55899     }
55900   }
55901
55902   jresult = result;
55903   return jresult;
55904 }
55905
55906
55907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55908   void * jresult ;
55909   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55910
55911   {
55912     try {
55913       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55914     } catch (std::out_of_range& e) {
55915       {
55916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55917       };
55918     } catch (std::exception& e) {
55919       {
55920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55921       };
55922     } catch (Dali::DaliException e) {
55923       {
55924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55925       };
55926     } catch (...) {
55927       {
55928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55929       };
55930     }
55931   }
55932
55933   jresult = (void *)result;
55934   return jresult;
55935 }
55936
55937
55938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55939   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55940
55941   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55942   {
55943     try {
55944       delete arg1;
55945     } catch (std::out_of_range& e) {
55946       {
55947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55948       };
55949     } catch (std::exception& e) {
55950       {
55951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55952       };
55953     } catch (Dali::DaliException e) {
55954       {
55955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55956       };
55957     } catch (...) {
55958       {
55959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55960       };
55961     }
55962   }
55963
55964 }
55965
55966
55967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55968   unsigned int jresult ;
55969   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55970   bool result;
55971
55972   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55973   {
55974     try {
55975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55976     } catch (std::out_of_range& e) {
55977       {
55978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (std::exception& e) {
55981       {
55982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55983       };
55984     } catch (Dali::DaliException e) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55987       };
55988     } catch (...) {
55989       {
55990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55991       };
55992     }
55993   }
55994
55995   jresult = result;
55996   return jresult;
55997 }
55998
55999
56000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
56001   unsigned long jresult ;
56002   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56003   std::size_t result;
56004
56005   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56006   {
56007     try {
56008       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56009     } catch (std::out_of_range& e) {
56010       {
56011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56012       };
56013     } catch (std::exception& e) {
56014       {
56015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56016       };
56017     } catch (Dali::DaliException e) {
56018       {
56019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56020       };
56021     } catch (...) {
56022       {
56023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56024       };
56025     }
56026   }
56027
56028   jresult = (unsigned long)result;
56029   return jresult;
56030 }
56031
56032
56033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56034   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56035   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56036
56037   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56038   arg2 = (void (*)(Dali::Actor))jarg2;
56039   {
56040     try {
56041       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56042     } catch (std::out_of_range& e) {
56043       {
56044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56045       };
56046     } catch (std::exception& e) {
56047       {
56048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56049       };
56050     } catch (Dali::DaliException e) {
56051       {
56052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56053       };
56054     } catch (...) {
56055       {
56056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56057       };
56058     }
56059   }
56060
56061 }
56062
56063
56064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56065   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56066   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56067
56068   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56069   arg2 = (void (*)(Dali::Actor))jarg2;
56070   {
56071     try {
56072       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56073     } catch (std::out_of_range& e) {
56074       {
56075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56076       };
56077     } catch (std::exception& e) {
56078       {
56079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56080       };
56081     } catch (Dali::DaliException e) {
56082       {
56083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56084       };
56085     } catch (...) {
56086       {
56087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56088       };
56089     }
56090   }
56091
56092 }
56093
56094
56095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56096   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56097   Dali::Actor arg2 ;
56098   Dali::Actor *argp2 ;
56099
56100   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56101   argp2 = (Dali::Actor *)jarg2;
56102   if (!argp2) {
56103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56104     return ;
56105   }
56106   arg2 = *argp2;
56107   {
56108     try {
56109       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56110     } catch (std::out_of_range& e) {
56111       {
56112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56113       };
56114     } catch (std::exception& e) {
56115       {
56116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56117       };
56118     } catch (Dali::DaliException e) {
56119       {
56120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56121       };
56122     } catch (...) {
56123       {
56124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56125       };
56126     }
56127   }
56128
56129 }
56130
56131
56132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56133   void * jresult ;
56134   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56135
56136   {
56137     try {
56138       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56139     } catch (std::out_of_range& e) {
56140       {
56141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56142       };
56143     } catch (std::exception& e) {
56144       {
56145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (Dali::DaliException e) {
56148       {
56149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56150       };
56151     } catch (...) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56154       };
56155     }
56156   }
56157
56158   jresult = (void *)result;
56159   return jresult;
56160 }
56161
56162
56163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56164   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56165
56166   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56167   {
56168     try {
56169       delete arg1;
56170     } catch (std::out_of_range& e) {
56171       {
56172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56173       };
56174     } catch (std::exception& e) {
56175       {
56176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56177       };
56178     } catch (Dali::DaliException e) {
56179       {
56180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56181       };
56182     } catch (...) {
56183       {
56184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56185       };
56186     }
56187   }
56188
56189 }
56190
56191
56192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56193   unsigned int jresult ;
56194   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56195   bool result;
56196
56197   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56198   {
56199     try {
56200       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56201     } catch (std::out_of_range& e) {
56202       {
56203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56204       };
56205     } catch (std::exception& e) {
56206       {
56207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56208       };
56209     } catch (Dali::DaliException e) {
56210       {
56211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56212       };
56213     } catch (...) {
56214       {
56215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56216       };
56217     }
56218   }
56219
56220   jresult = result;
56221   return jresult;
56222 }
56223
56224
56225 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56226   unsigned long jresult ;
56227   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56228   std::size_t result;
56229
56230   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56231   {
56232     try {
56233       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56234     } catch (std::out_of_range& e) {
56235       {
56236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56237       };
56238     } catch (std::exception& e) {
56239       {
56240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56241       };
56242     } catch (Dali::DaliException e) {
56243       {
56244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56245       };
56246     } catch (...) {
56247       {
56248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56249       };
56250     }
56251   }
56252
56253   jresult = (unsigned long)result;
56254   return jresult;
56255 }
56256
56257
56258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56259   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56260   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56261
56262   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56263   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56264   {
56265     try {
56266       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56267     } catch (std::out_of_range& e) {
56268       {
56269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56270       };
56271     } catch (std::exception& e) {
56272       {
56273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56274       };
56275     } catch (Dali::DaliException e) {
56276       {
56277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56278       };
56279     } catch (...) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56282       };
56283     }
56284   }
56285
56286 }
56287
56288
56289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56290   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56291   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56292
56293   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56294   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56295   {
56296     try {
56297       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56298     } catch (std::out_of_range& e) {
56299       {
56300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56301       };
56302     } catch (std::exception& e) {
56303       {
56304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56305       };
56306     } catch (Dali::DaliException e) {
56307       {
56308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56309       };
56310     } catch (...) {
56311       {
56312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56313       };
56314     }
56315   }
56316
56317 }
56318
56319
56320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56321   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56322   Dali::KeyEvent *arg2 = 0 ;
56323
56324   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56325   arg2 = (Dali::KeyEvent *)jarg2;
56326   if (!arg2) {
56327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56328     return ;
56329   }
56330   {
56331     try {
56332       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56333     } catch (std::out_of_range& e) {
56334       {
56335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56336       };
56337     } catch (std::exception& e) {
56338       {
56339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56340       };
56341     } catch (Dali::DaliException e) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56344       };
56345     } catch (...) {
56346       {
56347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56348       };
56349     }
56350   }
56351
56352 }
56353
56354
56355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56356   void * jresult ;
56357   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56358
56359   {
56360     try {
56361       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56362     } catch (std::out_of_range& e) {
56363       {
56364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56365       };
56366     } catch (std::exception& e) {
56367       {
56368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56369       };
56370     } catch (Dali::DaliException e) {
56371       {
56372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56373       };
56374     } catch (...) {
56375       {
56376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56377       };
56378     }
56379   }
56380
56381   jresult = (void *)result;
56382   return jresult;
56383 }
56384
56385
56386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56387   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56388
56389   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56390   {
56391     try {
56392       delete arg1;
56393     } catch (std::out_of_range& e) {
56394       {
56395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (std::exception& e) {
56398       {
56399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56400       };
56401     } catch (Dali::DaliException e) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56404       };
56405     } catch (...) {
56406       {
56407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56408       };
56409     }
56410   }
56411
56412 }
56413
56414
56415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56416   unsigned int jresult ;
56417   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56418   bool result;
56419
56420   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56421   {
56422     try {
56423       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56424     } catch (std::out_of_range& e) {
56425       {
56426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56427       };
56428     } catch (std::exception& e) {
56429       {
56430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56431       };
56432     } catch (Dali::DaliException e) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56435       };
56436     } catch (...) {
56437       {
56438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56439       };
56440     }
56441   }
56442
56443   jresult = result;
56444   return jresult;
56445 }
56446
56447
56448 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56449   unsigned long jresult ;
56450   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56451   std::size_t result;
56452
56453   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56454   {
56455     try {
56456       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56457     } catch (std::out_of_range& e) {
56458       {
56459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (std::exception& e) {
56462       {
56463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56464       };
56465     } catch (Dali::DaliException e) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56468       };
56469     } catch (...) {
56470       {
56471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56472       };
56473     }
56474   }
56475
56476   jresult = (unsigned long)result;
56477   return jresult;
56478 }
56479
56480
56481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56482   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56483   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56484
56485   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56486   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56487   {
56488     try {
56489       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56490     } catch (std::out_of_range& e) {
56491       {
56492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56493       };
56494     } catch (std::exception& e) {
56495       {
56496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56497       };
56498     } catch (Dali::DaliException e) {
56499       {
56500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56501       };
56502     } catch (...) {
56503       {
56504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56505       };
56506     }
56507   }
56508
56509 }
56510
56511
56512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56513   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56514   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56515
56516   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56517   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56518   {
56519     try {
56520       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56521     } catch (std::out_of_range& e) {
56522       {
56523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56524       };
56525     } catch (std::exception& e) {
56526       {
56527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56528       };
56529     } catch (Dali::DaliException e) {
56530       {
56531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56532       };
56533     } catch (...) {
56534       {
56535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56536       };
56537     }
56538   }
56539
56540 }
56541
56542
56543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56544   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56545   Dali::TouchData *arg2 = 0 ;
56546
56547   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56548   arg2 = (Dali::TouchData *)jarg2;
56549   if (!arg2) {
56550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56551     return ;
56552   }
56553   {
56554     try {
56555       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56556     } catch (std::out_of_range& e) {
56557       {
56558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56559       };
56560     } catch (std::exception& e) {
56561       {
56562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56563       };
56564     } catch (Dali::DaliException e) {
56565       {
56566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56567       };
56568     } catch (...) {
56569       {
56570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56571       };
56572     }
56573   }
56574
56575 }
56576
56577
56578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56579   void * jresult ;
56580   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56581
56582   {
56583     try {
56584       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56585     } catch (std::out_of_range& e) {
56586       {
56587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56588       };
56589     } catch (std::exception& e) {
56590       {
56591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56592       };
56593     } catch (Dali::DaliException e) {
56594       {
56595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56596       };
56597     } catch (...) {
56598       {
56599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56600       };
56601     }
56602   }
56603
56604   jresult = (void *)result;
56605   return jresult;
56606 }
56607
56608
56609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56610   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56611
56612   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56613   {
56614     try {
56615       delete arg1;
56616     } catch (std::out_of_range& e) {
56617       {
56618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56619       };
56620     } catch (std::exception& e) {
56621       {
56622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56623       };
56624     } catch (Dali::DaliException e) {
56625       {
56626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56627       };
56628     } catch (...) {
56629       {
56630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56631       };
56632     }
56633   }
56634
56635 }
56636
56637
56638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56639   unsigned int jresult ;
56640   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56641   bool result;
56642
56643   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56644   {
56645     try {
56646       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56647     } catch (std::out_of_range& e) {
56648       {
56649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56650       };
56651     } catch (std::exception& e) {
56652       {
56653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56654       };
56655     } catch (Dali::DaliException e) {
56656       {
56657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56658       };
56659     } catch (...) {
56660       {
56661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56662       };
56663     }
56664   }
56665
56666   jresult = result;
56667   return jresult;
56668 }
56669
56670
56671 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56672   unsigned long jresult ;
56673   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56674   std::size_t result;
56675
56676   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56677   {
56678     try {
56679       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56680     } catch (std::out_of_range& e) {
56681       {
56682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56683       };
56684     } catch (std::exception& e) {
56685       {
56686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56687       };
56688     } catch (Dali::DaliException e) {
56689       {
56690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56691       };
56692     } catch (...) {
56693       {
56694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56695       };
56696     }
56697   }
56698
56699   jresult = (unsigned long)result;
56700   return jresult;
56701 }
56702
56703
56704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56705   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56706   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56707
56708   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56709   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56710   {
56711     try {
56712       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56713     } catch (std::out_of_range& e) {
56714       {
56715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56716       };
56717     } catch (std::exception& e) {
56718       {
56719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56720       };
56721     } catch (Dali::DaliException e) {
56722       {
56723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56724       };
56725     } catch (...) {
56726       {
56727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56728       };
56729     }
56730   }
56731
56732 }
56733
56734
56735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56736   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56737   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56738
56739   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56740   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56741   {
56742     try {
56743       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56744     } catch (std::out_of_range& e) {
56745       {
56746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56747       };
56748     } catch (std::exception& e) {
56749       {
56750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56751       };
56752     } catch (Dali::DaliException e) {
56753       {
56754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56755       };
56756     } catch (...) {
56757       {
56758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56759       };
56760     }
56761   }
56762
56763 }
56764
56765
56766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56767   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56768   Dali::WheelEvent *arg2 = 0 ;
56769
56770   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56771   arg2 = (Dali::WheelEvent *)jarg2;
56772   if (!arg2) {
56773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56774     return ;
56775   }
56776   {
56777     try {
56778       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56779     } catch (std::out_of_range& e) {
56780       {
56781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56782       };
56783     } catch (std::exception& e) {
56784       {
56785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56786       };
56787     } catch (Dali::DaliException e) {
56788       {
56789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56790       };
56791     } catch (...) {
56792       {
56793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56794       };
56795     }
56796   }
56797
56798 }
56799
56800
56801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56802   void * jresult ;
56803   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56804
56805   {
56806     try {
56807       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56808     } catch (std::out_of_range& e) {
56809       {
56810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56811       };
56812     } catch (std::exception& e) {
56813       {
56814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56815       };
56816     } catch (Dali::DaliException e) {
56817       {
56818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56819       };
56820     } catch (...) {
56821       {
56822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56823       };
56824     }
56825   }
56826
56827   jresult = (void *)result;
56828   return jresult;
56829 }
56830
56831
56832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56833   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56834
56835   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56836   {
56837     try {
56838       delete arg1;
56839     } catch (std::out_of_range& e) {
56840       {
56841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56842       };
56843     } catch (std::exception& e) {
56844       {
56845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56846       };
56847     } catch (Dali::DaliException e) {
56848       {
56849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56850       };
56851     } catch (...) {
56852       {
56853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56854       };
56855     }
56856   }
56857
56858 }
56859
56860
56861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56862   void * jresult ;
56863   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56864
56865   {
56866     try {
56867       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56868     } catch (std::out_of_range& e) {
56869       {
56870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56871       };
56872     } catch (std::exception& e) {
56873       {
56874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56875       };
56876     } catch (Dali::DaliException e) {
56877       {
56878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56879       };
56880     } catch (...) {
56881       {
56882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56883       };
56884     }
56885   }
56886
56887   jresult = (void *)result;
56888   return jresult;
56889 }
56890
56891
56892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56893   void * jresult ;
56894   Dali::Radian arg1 ;
56895   Dali::Radian arg2 ;
56896   Dali::Radian *argp1 ;
56897   Dali::Radian *argp2 ;
56898   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56899
56900   argp1 = (Dali::Radian *)jarg1;
56901   if (!argp1) {
56902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56903     return 0;
56904   }
56905   arg1 = *argp1;
56906   argp2 = (Dali::Radian *)jarg2;
56907   if (!argp2) {
56908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56909     return 0;
56910   }
56911   arg2 = *argp2;
56912   {
56913     try {
56914       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56915     } catch (std::out_of_range& e) {
56916       {
56917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56918       };
56919     } catch (std::exception& e) {
56920       {
56921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56922       };
56923     } catch (Dali::DaliException e) {
56924       {
56925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56926       };
56927     } catch (...) {
56928       {
56929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56930       };
56931     }
56932   }
56933
56934   jresult = (void *)result;
56935   return jresult;
56936 }
56937
56938
56939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56940   void * jresult ;
56941   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56942   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56943
56944   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56945   if (!arg1) {
56946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56947     return 0;
56948   }
56949   {
56950     try {
56951       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56952     } catch (std::out_of_range& e) {
56953       {
56954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56955       };
56956     } catch (std::exception& e) {
56957       {
56958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56959       };
56960     } catch (Dali::DaliException e) {
56961       {
56962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56963       };
56964     } catch (...) {
56965       {
56966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56967       };
56968     }
56969   }
56970
56971   jresult = (void *)result;
56972   return jresult;
56973 }
56974
56975
56976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56977   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56978   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56979
56980   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56981   arg2 = (Dali::Radian *)jarg2;
56982   if (arg1) (arg1)->first = *arg2;
56983 }
56984
56985
56986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56987   void * jresult ;
56988   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56989   Dali::Radian *result = 0 ;
56990
56991   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56992   result = (Dali::Radian *)& ((arg1)->first);
56993   jresult = (void *)result;
56994   return jresult;
56995 }
56996
56997
56998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56999   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57000   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
57001
57002   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57003   arg2 = (Dali::Radian *)jarg2;
57004   if (arg1) (arg1)->second = *arg2;
57005 }
57006
57007
57008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57009   void * jresult ;
57010   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57011   Dali::Radian *result = 0 ;
57012
57013   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57014   result = (Dali::Radian *)& ((arg1)->second);
57015   jresult = (void *)result;
57016   return jresult;
57017 }
57018
57019
57020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57021   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57022
57023   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57024   {
57025     try {
57026       delete arg1;
57027     } catch (std::out_of_range& e) {
57028       {
57029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57030       };
57031     } catch (std::exception& e) {
57032       {
57033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57034       };
57035     } catch (Dali::DaliException e) {
57036       {
57037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57038       };
57039     } catch (...) {
57040       {
57041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57042       };
57043     }
57044   }
57045
57046 }
57047
57048
57049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57050   unsigned int jresult ;
57051   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57052   bool result;
57053
57054   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57055   {
57056     try {
57057       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);
57058     } catch (std::out_of_range& e) {
57059       {
57060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57061       };
57062     } catch (std::exception& e) {
57063       {
57064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57065       };
57066     } catch (Dali::DaliException e) {
57067       {
57068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57069       };
57070     } catch (...) {
57071       {
57072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57073       };
57074     }
57075   }
57076
57077   jresult = result;
57078   return jresult;
57079 }
57080
57081
57082 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57083   unsigned long jresult ;
57084   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57085   std::size_t result;
57086
57087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57088   {
57089     try {
57090       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);
57091     } catch (std::out_of_range& e) {
57092       {
57093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57094       };
57095     } catch (std::exception& e) {
57096       {
57097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57098       };
57099     } catch (Dali::DaliException e) {
57100       {
57101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57102       };
57103     } catch (...) {
57104       {
57105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57106       };
57107     }
57108   }
57109
57110   jresult = (unsigned long)result;
57111   return jresult;
57112 }
57113
57114
57115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57116   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57117   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57118
57119   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57120   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57121   {
57122     try {
57123       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57124     } catch (std::out_of_range& e) {
57125       {
57126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57127       };
57128     } catch (std::exception& e) {
57129       {
57130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57131       };
57132     } catch (Dali::DaliException e) {
57133       {
57134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57135       };
57136     } catch (...) {
57137       {
57138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57139       };
57140     }
57141   }
57142
57143 }
57144
57145
57146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57147   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57148   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57149
57150   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57151   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57152   {
57153     try {
57154       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57155     } catch (std::out_of_range& e) {
57156       {
57157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57158       };
57159     } catch (std::exception& e) {
57160       {
57161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57162       };
57163     } catch (Dali::DaliException e) {
57164       {
57165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57166       };
57167     } catch (...) {
57168       {
57169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57170       };
57171     }
57172   }
57173
57174 }
57175
57176
57177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57178   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57179   Dali::Actor arg2 ;
57180   Dali::PanGesture *arg3 = 0 ;
57181   Dali::Actor *argp2 ;
57182
57183   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57184   argp2 = (Dali::Actor *)jarg2;
57185   if (!argp2) {
57186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57187     return ;
57188   }
57189   arg2 = *argp2;
57190   arg3 = (Dali::PanGesture *)jarg3;
57191   if (!arg3) {
57192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57193     return ;
57194   }
57195   {
57196     try {
57197       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
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_new_PanGestureDetectedSignal() {
57221   void * jresult ;
57222   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57223
57224   {
57225     try {
57226       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57227     } catch (std::out_of_range& e) {
57228       {
57229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57230       };
57231     } catch (std::exception& e) {
57232       {
57233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57234       };
57235     } catch (Dali::DaliException e) {
57236       {
57237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57238       };
57239     } catch (...) {
57240       {
57241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57242       };
57243     }
57244   }
57245
57246   jresult = (void *)result;
57247   return jresult;
57248 }
57249
57250
57251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57252   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57253
57254   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57255   {
57256     try {
57257       delete arg1;
57258     } catch (std::out_of_range& e) {
57259       {
57260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (std::exception& e) {
57263       {
57264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57265       };
57266     } catch (Dali::DaliException e) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57269       };
57270     } catch (...) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57273       };
57274     }
57275   }
57276
57277 }
57278
57279
57280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57281   unsigned int jresult ;
57282   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57283   bool result;
57284
57285   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57286   {
57287     try {
57288       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);
57289     } catch (std::out_of_range& e) {
57290       {
57291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57292       };
57293     } catch (std::exception& e) {
57294       {
57295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57296       };
57297     } catch (Dali::DaliException e) {
57298       {
57299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57300       };
57301     } catch (...) {
57302       {
57303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57304       };
57305     }
57306   }
57307
57308   jresult = result;
57309   return jresult;
57310 }
57311
57312
57313 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57314   unsigned long jresult ;
57315   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57316   std::size_t result;
57317
57318   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57319   {
57320     try {
57321       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);
57322     } catch (std::out_of_range& e) {
57323       {
57324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57325       };
57326     } catch (std::exception& e) {
57327       {
57328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57329       };
57330     } catch (Dali::DaliException e) {
57331       {
57332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57333       };
57334     } catch (...) {
57335       {
57336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57337       };
57338     }
57339   }
57340
57341   jresult = (unsigned long)result;
57342   return jresult;
57343 }
57344
57345
57346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57347   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57348   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57349
57350   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57351   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57352   {
57353     try {
57354       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57355     } catch (std::out_of_range& e) {
57356       {
57357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57358       };
57359     } catch (std::exception& e) {
57360       {
57361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57362       };
57363     } catch (Dali::DaliException e) {
57364       {
57365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57366       };
57367     } catch (...) {
57368       {
57369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57370       };
57371     }
57372   }
57373
57374 }
57375
57376
57377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57378   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57379   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57380
57381   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57382   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57383   {
57384     try {
57385       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57386     } catch (std::out_of_range& e) {
57387       {
57388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57389       };
57390     } catch (std::exception& e) {
57391       {
57392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57393       };
57394     } catch (Dali::DaliException e) {
57395       {
57396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57397       };
57398     } catch (...) {
57399       {
57400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57401       };
57402     }
57403   }
57404
57405 }
57406
57407
57408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57409   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57410   Dali::Actor arg2 ;
57411   Dali::PinchGesture *arg3 = 0 ;
57412   Dali::Actor *argp2 ;
57413
57414   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57415   argp2 = (Dali::Actor *)jarg2;
57416   if (!argp2) {
57417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57418     return ;
57419   }
57420   arg2 = *argp2;
57421   arg3 = (Dali::PinchGesture *)jarg3;
57422   if (!arg3) {
57423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57424     return ;
57425   }
57426   {
57427     try {
57428       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
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_new_PinchGestureDetectedSignal() {
57452   void * jresult ;
57453   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57454
57455   {
57456     try {
57457       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57458     } catch (std::out_of_range& e) {
57459       {
57460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57461       };
57462     } catch (std::exception& e) {
57463       {
57464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57465       };
57466     } catch (Dali::DaliException e) {
57467       {
57468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57469       };
57470     } catch (...) {
57471       {
57472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57473       };
57474     }
57475   }
57476
57477   jresult = (void *)result;
57478   return jresult;
57479 }
57480
57481
57482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57483   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57484
57485   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57486   {
57487     try {
57488       delete arg1;
57489     } catch (std::out_of_range& e) {
57490       {
57491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57492       };
57493     } catch (std::exception& e) {
57494       {
57495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57496       };
57497     } catch (Dali::DaliException e) {
57498       {
57499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57500       };
57501     } catch (...) {
57502       {
57503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57504       };
57505     }
57506   }
57507
57508 }
57509
57510
57511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57512   unsigned int jresult ;
57513   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57514   bool result;
57515
57516   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57517   {
57518     try {
57519       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);
57520     } catch (std::out_of_range& e) {
57521       {
57522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57523       };
57524     } catch (std::exception& e) {
57525       {
57526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57527       };
57528     } catch (Dali::DaliException e) {
57529       {
57530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57531       };
57532     } catch (...) {
57533       {
57534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57535       };
57536     }
57537   }
57538
57539   jresult = result;
57540   return jresult;
57541 }
57542
57543
57544 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57545   unsigned long jresult ;
57546   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57547   std::size_t result;
57548
57549   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57550   {
57551     try {
57552       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);
57553     } catch (std::out_of_range& e) {
57554       {
57555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57556       };
57557     } catch (std::exception& e) {
57558       {
57559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57560       };
57561     } catch (Dali::DaliException e) {
57562       {
57563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57564       };
57565     } catch (...) {
57566       {
57567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57568       };
57569     }
57570   }
57571
57572   jresult = (unsigned long)result;
57573   return jresult;
57574 }
57575
57576
57577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57578   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57579   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57580
57581   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57582   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57583   {
57584     try {
57585       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57586     } catch (std::out_of_range& e) {
57587       {
57588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57589       };
57590     } catch (std::exception& e) {
57591       {
57592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57593       };
57594     } catch (Dali::DaliException e) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57597       };
57598     } catch (...) {
57599       {
57600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57601       };
57602     }
57603   }
57604
57605 }
57606
57607
57608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57609   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57610   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57611
57612   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57613   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57614   {
57615     try {
57616       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57617     } catch (std::out_of_range& e) {
57618       {
57619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57620       };
57621     } catch (std::exception& e) {
57622       {
57623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57624       };
57625     } catch (Dali::DaliException e) {
57626       {
57627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57628       };
57629     } catch (...) {
57630       {
57631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57632       };
57633     }
57634   }
57635
57636 }
57637
57638
57639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57640   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57641   Dali::Actor arg2 ;
57642   Dali::TapGesture *arg3 = 0 ;
57643   Dali::Actor *argp2 ;
57644
57645   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57646   argp2 = (Dali::Actor *)jarg2;
57647   if (!argp2) {
57648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57649     return ;
57650   }
57651   arg2 = *argp2;
57652   arg3 = (Dali::TapGesture *)jarg3;
57653   if (!arg3) {
57654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57655     return ;
57656   }
57657   {
57658     try {
57659       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
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_new_TapGestureDetectedSignal() {
57683   void * jresult ;
57684   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57685
57686   {
57687     try {
57688       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57689     } catch (std::out_of_range& e) {
57690       {
57691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (std::exception& e) {
57694       {
57695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (Dali::DaliException e) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57700       };
57701     } catch (...) {
57702       {
57703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57704       };
57705     }
57706   }
57707
57708   jresult = (void *)result;
57709   return jresult;
57710 }
57711
57712
57713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57714   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57715
57716   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57717   {
57718     try {
57719       delete arg1;
57720     } catch (std::out_of_range& e) {
57721       {
57722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57723       };
57724     } catch (std::exception& e) {
57725       {
57726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57727       };
57728     } catch (Dali::DaliException e) {
57729       {
57730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57731       };
57732     } catch (...) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57735       };
57736     }
57737   }
57738
57739 }
57740
57741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57742   unsigned int jresult ;
57743   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57744   bool result;
57745
57746   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57747   {
57748     try {
57749       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57750     } catch (std::out_of_range& e) {
57751       {
57752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57753       };
57754     } catch (std::exception& e) {
57755       {
57756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57757       };
57758     } catch (Dali::DaliException e) {
57759       {
57760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57761       };
57762     } catch (...) {
57763       {
57764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57765       };
57766     }
57767   }
57768
57769   jresult = result;
57770   return jresult;
57771 }
57772
57773
57774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57775   unsigned long jresult ;
57776   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57777   std::size_t result;
57778
57779   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57780   {
57781     try {
57782       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57783     } catch (std::out_of_range& e) {
57784       {
57785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57786       };
57787     } catch (std::exception& e) {
57788       {
57789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57790       };
57791     } catch (Dali::DaliException e) {
57792       {
57793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57794       };
57795     } catch (...) {
57796       {
57797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57798       };
57799     }
57800   }
57801
57802   jresult = (unsigned long)result;
57803   return jresult;
57804 }
57805
57806
57807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57808   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57809   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57810
57811   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57812   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57813   {
57814     try {
57815       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57816     } catch (std::out_of_range& e) {
57817       {
57818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57819       };
57820     } catch (std::exception& e) {
57821       {
57822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57823       };
57824     } catch (Dali::DaliException e) {
57825       {
57826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57827       };
57828     } catch (...) {
57829       {
57830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57831       };
57832     }
57833   }
57834
57835 }
57836
57837
57838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57839   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57840   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57841
57842   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57843   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57844   {
57845     try {
57846       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57847     } catch (std::out_of_range& e) {
57848       {
57849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57850       };
57851     } catch (std::exception& e) {
57852       {
57853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57854       };
57855     } catch (Dali::DaliException e) {
57856       {
57857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57858       };
57859     } catch (...) {
57860       {
57861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57862       };
57863     }
57864   }
57865
57866 }
57867
57868
57869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57870   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57871   Dali::ResourceImage arg2 ;
57872   Dali::ResourceImage *argp2 ;
57873
57874   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57875   argp2 = (Dali::ResourceImage *)jarg2;
57876   if (!argp2) {
57877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57878     return ;
57879   }
57880   arg2 = *argp2;
57881   {
57882     try {
57883       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57899       };
57900     }
57901   }
57902
57903 }
57904
57905
57906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57907   void * jresult ;
57908   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57909
57910   {
57911     try {
57912       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57913     } catch (std::out_of_range& e) {
57914       {
57915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57916       };
57917     } catch (std::exception& e) {
57918       {
57919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57920       };
57921     } catch (Dali::DaliException e) {
57922       {
57923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57924       };
57925     } catch (...) {
57926       {
57927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57928       };
57929     }
57930   }
57931
57932   jresult = (void *)result;
57933   return jresult;
57934 }
57935
57936
57937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57938   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57939
57940   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57941   {
57942     try {
57943       delete arg1;
57944     } catch (std::out_of_range& e) {
57945       {
57946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57947       };
57948     } catch (std::exception& e) {
57949       {
57950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57951       };
57952     } catch (Dali::DaliException e) {
57953       {
57954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57955       };
57956     } catch (...) {
57957       {
57958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57959       };
57960     }
57961   }
57962
57963 }
57964
57965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57966   unsigned int jresult ;
57967   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57968   bool result = false;
57969
57970   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57971   {
57972     try {
57973       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);
57974     } catch (std::out_of_range& e) {
57975       {
57976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57977       };
57978     } catch (std::exception& e) {
57979       {
57980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57981       };
57982     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57983   }
57984   jresult = result;
57985   return jresult;
57986 }
57987
57988 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57989   unsigned long jresult ;
57990   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57991   std::size_t result = 0;
57992
57993   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57994   {
57995     try {
57996       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);
57997     } catch (std::out_of_range& e) {
57998       {
57999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (std::exception& e) {
58002       {
58003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58004       };
58005     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58006   }
58007   jresult = (unsigned long)result;
58008   return jresult;
58009 }
58010
58011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58012   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58013   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58014
58015   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58016   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58017   {
58018     try {
58019       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58020     } catch (std::out_of_range& e) {
58021       {
58022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58023       };
58024     } catch (std::exception& e) {
58025       {
58026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58027       };
58028     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58029   }
58030 }
58031
58032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58033   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58034   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58035
58036   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58037   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58038   {
58039     try {
58040       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58041     } catch (std::out_of_range& e) {
58042       {
58043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58044       };
58045     } catch (std::exception& e) {
58046       {
58047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58048       };
58049     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58050   }
58051 }
58052
58053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58054   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58055   Dali::Actor arg2 ;
58056   //bool arg3 ;
58057   Dali::LayoutDirection::Type arg4 ;
58058   Dali::Actor *argp2 ;
58059
58060   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58061   argp2 = (Dali::Actor *)jarg2;
58062   if (!argp2) {
58063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58064     return ;
58065   }
58066   arg2 = *argp2;
58067   //arg3 = jarg3 ? true : false;
58068   arg4 = (Dali::LayoutDirection::Type)jarg4;
58069   {
58070     try {
58071       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58072     } catch (std::out_of_range& e) {
58073       {
58074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58075       };
58076     } catch (std::exception& e) {
58077       {
58078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58079       };
58080     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58081   }
58082 }
58083
58084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58085   void * jresult ;
58086   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58087
58088   {
58089     try {
58090       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58091     } catch (std::out_of_range& e) {
58092       {
58093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58094       };
58095     } catch (std::exception& e) {
58096       {
58097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58098       };
58099     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58100   }
58101   jresult = (void *)result;
58102   return jresult;
58103 }
58104
58105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58106   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58107
58108   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58109   {
58110     try {
58111       delete arg1;
58112     } catch (std::out_of_range& e) {
58113       {
58114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58115       };
58116     } catch (std::exception& e) {
58117       {
58118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58119       };
58120     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58121   }
58122 }
58123
58124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58125   unsigned int jresult ;
58126   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58127   bool result;
58128
58129   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58130   {
58131     try {
58132       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);
58133     } catch (std::out_of_range& e) {
58134       {
58135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (std::exception& e) {
58138       {
58139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58140       };
58141     } catch (Dali::DaliException e) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58144       };
58145     } catch (...) {
58146       {
58147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58148       };
58149     }
58150   }
58151
58152   jresult = result;
58153   return jresult;
58154 }
58155
58156
58157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58158   unsigned long jresult ;
58159   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58160   std::size_t result;
58161
58162   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58163   {
58164     try {
58165       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);
58166     } catch (std::out_of_range& e) {
58167       {
58168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58169       };
58170     } catch (std::exception& e) {
58171       {
58172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58173       };
58174     } catch (Dali::DaliException e) {
58175       {
58176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58177       };
58178     } catch (...) {
58179       {
58180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58181       };
58182     }
58183   }
58184
58185   jresult = (unsigned long)result;
58186   return jresult;
58187 }
58188
58189
58190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58191   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58192   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58193
58194   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58195   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58196   {
58197     try {
58198       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58199     } catch (std::out_of_range& e) {
58200       {
58201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58202       };
58203     } catch (std::exception& e) {
58204       {
58205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58206       };
58207     } catch (Dali::DaliException e) {
58208       {
58209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58210       };
58211     } catch (...) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58214       };
58215     }
58216   }
58217
58218 }
58219
58220
58221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58222   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58223   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58224
58225   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58226   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58227   {
58228     try {
58229       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58230     } catch (std::out_of_range& e) {
58231       {
58232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58233       };
58234     } catch (std::exception& e) {
58235       {
58236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58237       };
58238     } catch (Dali::DaliException e) {
58239       {
58240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58241       };
58242     } catch (...) {
58243       {
58244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58245       };
58246     }
58247   }
58248
58249 }
58250
58251
58252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58253   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58254   Dali::Actor arg2 ;
58255   bool arg3 ;
58256   Dali::DevelActor::VisibilityChange::Type arg4 ;
58257   Dali::Actor *argp2 ;
58258
58259   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58260   argp2 = (Dali::Actor *)jarg2;
58261   if (!argp2) {
58262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58263     return ;
58264   }
58265   arg2 = *argp2;
58266   arg3 = jarg3 ? true : false;
58267   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58268   {
58269     try {
58270       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58271     } catch (std::out_of_range& e) {
58272       {
58273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58274       };
58275     } catch (std::exception& e) {
58276       {
58277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58278       };
58279     } catch (Dali::DaliException e) {
58280       {
58281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58282       };
58283     } catch (...) {
58284       {
58285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58286       };
58287     }
58288   }
58289
58290 }
58291
58292
58293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58294   void * jresult ;
58295   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58296
58297   {
58298     try {
58299       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58300     } catch (std::out_of_range& e) {
58301       {
58302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58303       };
58304     } catch (std::exception& e) {
58305       {
58306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58307       };
58308     } catch (Dali::DaliException e) {
58309       {
58310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58311       };
58312     } catch (...) {
58313       {
58314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58315       };
58316     }
58317   }
58318
58319   jresult = (void *)result;
58320   return jresult;
58321 }
58322
58323
58324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58325   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58326
58327   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58328   {
58329     try {
58330       delete arg1;
58331     } catch (std::out_of_range& e) {
58332       {
58333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58334       };
58335     } catch (std::exception& e) {
58336       {
58337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58338       };
58339     } catch (Dali::DaliException e) {
58340       {
58341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58342       };
58343     } catch (...) {
58344       {
58345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58346       };
58347     }
58348   }
58349
58350 }
58351
58352
58353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58354   void * jresult ;
58355   Dali::Timer *result = 0 ;
58356
58357   {
58358     try {
58359       result = (Dali::Timer *)new Dali::Timer();
58360     } catch (std::out_of_range& e) {
58361       {
58362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58363       };
58364     } catch (std::exception& e) {
58365       {
58366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58367       };
58368     } catch (Dali::DaliException e) {
58369       {
58370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58371       };
58372     } catch (...) {
58373       {
58374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58375       };
58376     }
58377   }
58378
58379   jresult = (void *)result;
58380   return jresult;
58381 }
58382
58383
58384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58385   void * jresult ;
58386   unsigned int arg1 ;
58387   Dali::Timer result;
58388
58389   arg1 = (unsigned int)jarg1;
58390   {
58391     try {
58392       result = Dali::Timer::New(arg1);
58393     } catch (std::out_of_range& e) {
58394       {
58395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58396       };
58397     } catch (std::exception& e) {
58398       {
58399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58400       };
58401     } catch (Dali::DaliException e) {
58402       {
58403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58404       };
58405     } catch (...) {
58406       {
58407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58408       };
58409     }
58410   }
58411
58412   jresult = new Dali::Timer((const Dali::Timer &)result);
58413   return jresult;
58414 }
58415
58416
58417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58418   void * jresult ;
58419   Dali::Timer *arg1 = 0 ;
58420   Dali::Timer *result = 0 ;
58421
58422   arg1 = (Dali::Timer *)jarg1;
58423   if (!arg1) {
58424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58425     return 0;
58426   }
58427   {
58428     try {
58429       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (Dali::DaliException e) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58445       };
58446     }
58447   }
58448
58449   jresult = (void *)result;
58450   return jresult;
58451 }
58452
58453
58454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58455   void * jresult ;
58456   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58457   Dali::Timer *arg2 = 0 ;
58458   Dali::Timer *result = 0 ;
58459
58460   arg1 = (Dali::Timer *)jarg1;
58461   arg2 = (Dali::Timer *)jarg2;
58462   if (!arg2) {
58463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58464     return 0;
58465   }
58466   {
58467     try {
58468       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
58469     } catch (std::out_of_range& e) {
58470       {
58471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58472       };
58473     } catch (std::exception& e) {
58474       {
58475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58476       };
58477     } catch (Dali::DaliException e) {
58478       {
58479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58480       };
58481     } catch (...) {
58482       {
58483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58484       };
58485     }
58486   }
58487
58488   jresult = (void *)result;
58489   return jresult;
58490 }
58491
58492
58493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
58494   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58495
58496   arg1 = (Dali::Timer *)jarg1;
58497   {
58498     try {
58499       delete arg1;
58500     } catch (std::out_of_range& e) {
58501       {
58502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58503       };
58504     } catch (std::exception& e) {
58505       {
58506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58507       };
58508     } catch (Dali::DaliException e) {
58509       {
58510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58511       };
58512     } catch (...) {
58513       {
58514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58515       };
58516     }
58517   }
58518
58519 }
58520
58521
58522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58523   void * jresult ;
58524   Dali::BaseHandle arg1 ;
58525   Dali::BaseHandle *argp1 ;
58526   Dali::Timer result;
58527
58528   argp1 = (Dali::BaseHandle *)jarg1;
58529   if (!argp1) {
58530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58531     return 0;
58532   }
58533   arg1 = *argp1;
58534   {
58535     try {
58536       result = Dali::Timer::DownCast(arg1);
58537     } catch (std::out_of_range& e) {
58538       {
58539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58540       };
58541     } catch (std::exception& e) {
58542       {
58543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58544       };
58545     } catch (Dali::DaliException e) {
58546       {
58547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58548       };
58549     } catch (...) {
58550       {
58551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58552       };
58553     }
58554   }
58555
58556   jresult = new Dali::Timer((const Dali::Timer &)result);
58557   return jresult;
58558 }
58559
58560
58561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58562   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58563
58564   arg1 = (Dali::Timer *)jarg1;
58565   {
58566     try {
58567       (arg1)->Start();
58568     } catch (std::out_of_range& e) {
58569       {
58570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58571       };
58572     } catch (std::exception& e) {
58573       {
58574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58575       };
58576     } catch (Dali::DaliException e) {
58577       {
58578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58579       };
58580     } catch (...) {
58581       {
58582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58583       };
58584     }
58585   }
58586
58587 }
58588
58589
58590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58591   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58592
58593   arg1 = (Dali::Timer *)jarg1;
58594   {
58595     try {
58596       (arg1)->Stop();
58597     } catch (std::out_of_range& e) {
58598       {
58599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58600       };
58601     } catch (std::exception& e) {
58602       {
58603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58604       };
58605     } catch (Dali::DaliException e) {
58606       {
58607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58608       };
58609     } catch (...) {
58610       {
58611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58612       };
58613     }
58614   }
58615
58616 }
58617
58618
58619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58620   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58621   unsigned int arg2 ;
58622
58623   arg1 = (Dali::Timer *)jarg1;
58624   arg2 = (unsigned int)jarg2;
58625   {
58626     try {
58627       (arg1)->SetInterval(arg2);
58628     } catch (std::out_of_range& e) {
58629       {
58630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58631       };
58632     } catch (std::exception& e) {
58633       {
58634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58635       };
58636     } catch (Dali::DaliException e) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58639       };
58640     } catch (...) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58643       };
58644     }
58645   }
58646
58647 }
58648
58649
58650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58651   unsigned int jresult ;
58652   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58653   unsigned int result;
58654
58655   arg1 = (Dali::Timer *)jarg1;
58656   {
58657     try {
58658       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58659     } catch (std::out_of_range& e) {
58660       {
58661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58662       };
58663     } catch (std::exception& e) {
58664       {
58665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58666       };
58667     } catch (Dali::DaliException e) {
58668       {
58669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58670       };
58671     } catch (...) {
58672       {
58673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58674       };
58675     }
58676   }
58677
58678   jresult = result;
58679   return jresult;
58680 }
58681
58682
58683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58684   unsigned int jresult ;
58685   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58686   bool result;
58687
58688   arg1 = (Dali::Timer *)jarg1;
58689   {
58690     try {
58691       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58692     } catch (std::out_of_range& e) {
58693       {
58694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58695       };
58696     } catch (std::exception& e) {
58697       {
58698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58699       };
58700     } catch (Dali::DaliException e) {
58701       {
58702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58703       };
58704     } catch (...) {
58705       {
58706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58707       };
58708     }
58709   }
58710
58711   jresult = result;
58712   return jresult;
58713 }
58714
58715
58716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58717   void * jresult ;
58718   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58719   Dali::Timer::TimerSignalType *result = 0 ;
58720
58721   arg1 = (Dali::Timer *)jarg1;
58722   {
58723     try {
58724       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58725     } catch (std::out_of_range& e) {
58726       {
58727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (std::exception& e) {
58730       {
58731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58732       };
58733     } catch (Dali::DaliException e) {
58734       {
58735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58736       };
58737     } catch (...) {
58738       {
58739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58740       };
58741     }
58742   }
58743
58744   jresult = (void *)result;
58745   return jresult;
58746 }
58747
58748
58749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DragAndDropDetector() {
58750   void * jresult ;
58751   Dali::DragAndDropDetector *result = 0 ;
58752
58753   {
58754     try {
58755       result = (Dali::DragAndDropDetector *)new Dali::DragAndDropDetector();
58756     } catch (std::out_of_range& e) {
58757       {
58758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58759       };
58760     } catch (std::exception& e) {
58761       {
58762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58763       };
58764     } catch (Dali::DaliException e) {
58765       {
58766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58767       };
58768     } catch (...) {
58769       {
58770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58771       };
58772     }
58773   }
58774
58775   jresult = (void *)result;
58776   return jresult;
58777 }
58778
58779
58780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DragAndDropDetector(void * jarg1) {
58781   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58782
58783   arg1 = (Dali::DragAndDropDetector *)jarg1;
58784   {
58785     try {
58786       delete arg1;
58787     } catch (std::out_of_range& e) {
58788       {
58789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58790       };
58791     } catch (std::exception& e) {
58792       {
58793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58794       };
58795     } catch (Dali::DaliException e) {
58796       {
58797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58798       };
58799     } catch (...) {
58800       {
58801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58802       };
58803     }
58804   }
58805
58806 }
58807
58808
58809 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetContent(void * jarg1) {
58810   char * jresult ;
58811   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58812   std::string *result = 0 ;
58813
58814   arg1 = (Dali::DragAndDropDetector *)jarg1;
58815   {
58816     try {
58817       result = (std::string *) &((Dali::DragAndDropDetector const *)arg1)->GetContent();
58818     } catch (std::out_of_range& e) {
58819       {
58820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58821       };
58822     } catch (std::exception& e) {
58823       {
58824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58825       };
58826     } catch (Dali::DaliException e) {
58827       {
58828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58829       };
58830     } catch (...) {
58831       {
58832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58833       };
58834     }
58835   }
58836
58837   jresult = SWIG_csharp_string_callback(result->c_str());
58838   return jresult;
58839 }
58840
58841
58842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_GetCurrentScreenPosition(void * jarg1) {
58843   void * jresult ;
58844   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58845   Dali::Vector2 result;
58846
58847   arg1 = (Dali::DragAndDropDetector *)jarg1;
58848   {
58849     try {
58850       result = ((Dali::DragAndDropDetector const *)arg1)->GetCurrentScreenPosition();
58851     } catch (std::out_of_range& e) {
58852       {
58853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58854       };
58855     } catch (std::exception& e) {
58856       {
58857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58858       };
58859     } catch (Dali::DaliException e) {
58860       {
58861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58862       };
58863     } catch (...) {
58864       {
58865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58866       };
58867     }
58868   }
58869
58870   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
58871   return jresult;
58872 }
58873
58874
58875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_EnteredSignal(void * jarg1) {
58876   void * jresult ;
58877   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58878   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58879
58880   arg1 = (Dali::DragAndDropDetector *)jarg1;
58881   {
58882     try {
58883       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->EnteredSignal();
58884     } catch (std::out_of_range& e) {
58885       {
58886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58887       };
58888     } catch (std::exception& e) {
58889       {
58890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58891       };
58892     } catch (Dali::DaliException e) {
58893       {
58894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58895       };
58896     } catch (...) {
58897       {
58898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58899       };
58900     }
58901   }
58902
58903   jresult = (void *)result;
58904   return jresult;
58905 }
58906
58907
58908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_ExitedSignal(void * jarg1) {
58909   void * jresult ;
58910   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58911   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58912
58913   arg1 = (Dali::DragAndDropDetector *)jarg1;
58914   {
58915     try {
58916       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->ExitedSignal();
58917     } catch (std::out_of_range& e) {
58918       {
58919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58920       };
58921     } catch (std::exception& e) {
58922       {
58923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58924       };
58925     } catch (Dali::DaliException e) {
58926       {
58927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58928       };
58929     } catch (...) {
58930       {
58931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58932       };
58933     }
58934   }
58935
58936   jresult = (void *)result;
58937   return jresult;
58938 }
58939
58940
58941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_MovedSignal(void * jarg1) {
58942   void * jresult ;
58943   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58944   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58945
58946   arg1 = (Dali::DragAndDropDetector *)jarg1;
58947   {
58948     try {
58949       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->MovedSignal();
58950     } catch (std::out_of_range& e) {
58951       {
58952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58953       };
58954     } catch (std::exception& e) {
58955       {
58956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58957       };
58958     } catch (Dali::DaliException e) {
58959       {
58960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58961       };
58962     } catch (...) {
58963       {
58964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58965       };
58966     }
58967   }
58968
58969   jresult = (void *)result;
58970   return jresult;
58971 }
58972
58973
58974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_DroppedSignal(void * jarg1) {
58975   void * jresult ;
58976   Dali::DragAndDropDetector *arg1 = (Dali::DragAndDropDetector *) 0 ;
58977   Dali::DragAndDropDetector::DragAndDropSignal *result = 0 ;
58978
58979   arg1 = (Dali::DragAndDropDetector *)jarg1;
58980   {
58981     try {
58982       result = (Dali::DragAndDropDetector::DragAndDropSignal *) &(arg1)->DroppedSignal();
58983     } catch (std::out_of_range& e) {
58984       {
58985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58986       };
58987     } catch (std::exception& e) {
58988       {
58989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58990       };
58991     } catch (Dali::DaliException e) {
58992       {
58993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58994       };
58995     } catch (...) {
58996       {
58997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58998       };
58999     }
59000   }
59001
59002   jresult = (void *)result;
59003   return jresult;
59004 }
59005
59006
59007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_0() {
59008   void * jresult ;
59009   Dali::ApplicationExtensions *result = 0 ;
59010
59011   {
59012     try {
59013       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions();
59014     } catch (std::out_of_range& e) {
59015       {
59016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59017       };
59018     } catch (std::exception& e) {
59019       {
59020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (Dali::DaliException e) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59025       };
59026     } catch (...) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59029       };
59030     }
59031   }
59032
59033   jresult = (void *)result;
59034   return jresult;
59035 }
59036
59037
59038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ApplicationExtensions__SWIG_1(void * jarg1) {
59039   void * jresult ;
59040   Dali::Application *arg1 = (Dali::Application *) 0 ;
59041   Dali::ApplicationExtensions *result = 0 ;
59042
59043   arg1 = (Dali::Application *)jarg1;
59044   {
59045     try {
59046       result = (Dali::ApplicationExtensions *)new Dali::ApplicationExtensions(arg1);
59047     } catch (std::out_of_range& e) {
59048       {
59049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59050       };
59051     } catch (std::exception& e) {
59052       {
59053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59054       };
59055     } catch (Dali::DaliException e) {
59056       {
59057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59058       };
59059     } catch (...) {
59060       {
59061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59062       };
59063     }
59064   }
59065
59066   jresult = (void *)result;
59067   return jresult;
59068 }
59069
59070
59071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ApplicationExtensions(void * jarg1) {
59072   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59073
59074   arg1 = (Dali::ApplicationExtensions *)jarg1;
59075   {
59076     try {
59077       delete arg1;
59078     } catch (std::out_of_range& e) {
59079       {
59080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59081       };
59082     } catch (std::exception& e) {
59083       {
59084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59085       };
59086     } catch (Dali::DaliException e) {
59087       {
59088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59089       };
59090     } catch (...) {
59091       {
59092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59093       };
59094     }
59095   }
59096
59097 }
59098
59099
59100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Init(void * jarg1) {
59101   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59102
59103   arg1 = (Dali::ApplicationExtensions *)jarg1;
59104   {
59105     try {
59106       (arg1)->Init();
59107     } catch (std::out_of_range& e) {
59108       {
59109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59110       };
59111     } catch (std::exception& e) {
59112       {
59113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59114       };
59115     } catch (Dali::DaliException e) {
59116       {
59117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59118       };
59119     } catch (...) {
59120       {
59121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59122       };
59123     }
59124   }
59125
59126 }
59127
59128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Start(void * jarg1) {
59129   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59130
59131   arg1 = (Dali::ApplicationExtensions *)jarg1;
59132   {
59133     try {
59134       (arg1)->Start();
59135     } catch (std::out_of_range& e) {
59136       {
59137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59138       };
59139     } catch (std::exception& e) {
59140       {
59141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59142       };
59143     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ; }
59144   }
59145 }
59146
59147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Terminate(void * jarg1) {
59148   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59149
59150   arg1 = (Dali::ApplicationExtensions *)jarg1;
59151   {
59152     try {
59153       (arg1)->Terminate();
59154     } catch (std::out_of_range& e) {
59155       {
59156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59157       };
59158     } catch (std::exception& e) {
59159       {
59160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59161       };
59162     } catch (Dali::DaliException e) {
59163       {
59164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59165       };
59166     } catch (...) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59169       };
59170     }
59171   }
59172
59173 }
59174
59175
59176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Pause(void * jarg1) {
59177   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59178
59179   arg1 = (Dali::ApplicationExtensions *)jarg1;
59180   {
59181     try {
59182       (arg1)->Pause();
59183     } catch (std::out_of_range& e) {
59184       {
59185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59186       };
59187     } catch (std::exception& e) {
59188       {
59189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59190       };
59191     } catch (Dali::DaliException e) {
59192       {
59193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59194       };
59195     } catch (...) {
59196       {
59197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59198       };
59199     }
59200   }
59201
59202 }
59203
59204
59205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_Resume(void * jarg1) {
59206   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59207
59208   arg1 = (Dali::ApplicationExtensions *)jarg1;
59209   {
59210     try {
59211       (arg1)->Resume();
59212     } catch (std::out_of_range& e) {
59213       {
59214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59215       };
59216     } catch (std::exception& e) {
59217       {
59218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59219       };
59220     } catch (Dali::DaliException e) {
59221       {
59222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59223       };
59224     } catch (...) {
59225       {
59226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59227       };
59228     }
59229   }
59230
59231 }
59232
59233
59234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ApplicationExtensions_LanguageChange(void * jarg1) {
59235   Dali::ApplicationExtensions *arg1 = (Dali::ApplicationExtensions *) 0 ;
59236
59237   arg1 = (Dali::ApplicationExtensions *)jarg1;
59238   {
59239     try {
59240       (arg1)->LanguageChange();
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59248       };
59249     } catch (Dali::DaliException e) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59256       };
59257     }
59258   }
59259
59260 }
59261
59262
59263
59264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
59265   unsigned int jresult ;
59266   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59267   bool result;
59268
59269   arg1 = (Dali::Signal< bool () > *)jarg1;
59270   {
59271     try {
59272       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
59273     } catch (std::out_of_range& e) {
59274       {
59275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59276       };
59277     } catch (std::exception& e) {
59278       {
59279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59280       };
59281     } catch (Dali::DaliException e) {
59282       {
59283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59284       };
59285     } catch (...) {
59286       {
59287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59288       };
59289     }
59290   }
59291
59292   jresult = result;
59293   return jresult;
59294 }
59295
59296
59297 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
59298   unsigned long jresult ;
59299   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59300   std::size_t result;
59301
59302   arg1 = (Dali::Signal< bool () > *)jarg1;
59303   {
59304     try {
59305       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
59306     } catch (std::out_of_range& e) {
59307       {
59308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59309       };
59310     } catch (std::exception& e) {
59311       {
59312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59313       };
59314     } catch (Dali::DaliException e) {
59315       {
59316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59317       };
59318     } catch (...) {
59319       {
59320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59321       };
59322     }
59323   }
59324
59325   jresult = (unsigned long)result;
59326   return jresult;
59327 }
59328
59329
59330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
59331   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59332   bool (*arg2)() = (bool (*)()) 0 ;
59333
59334   arg1 = (Dali::Signal< bool () > *)jarg1;
59335   arg2 = (bool (*)())jarg2;
59336   {
59337     try {
59338       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
59339     } catch (std::out_of_range& e) {
59340       {
59341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59342       };
59343     } catch (std::exception& e) {
59344       {
59345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59346       };
59347     } catch (Dali::DaliException e) {
59348       {
59349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59350       };
59351     } catch (...) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59354       };
59355     }
59356   }
59357
59358 }
59359
59360
59361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
59362   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59363   bool (*arg2)() = (bool (*)()) 0 ;
59364
59365   arg1 = (Dali::Signal< bool () > *)jarg1;
59366   arg2 = (bool (*)())jarg2;
59367   {
59368     try {
59369       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
59370     } catch (std::out_of_range& e) {
59371       {
59372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59373       };
59374     } catch (std::exception& e) {
59375       {
59376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59377       };
59378     } catch (Dali::DaliException e) {
59379       {
59380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59381       };
59382     } catch (...) {
59383       {
59384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59385       };
59386     }
59387   }
59388
59389 }
59390
59391
59392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
59393   unsigned int jresult ;
59394   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59395   bool result;
59396
59397   arg1 = (Dali::Signal< bool () > *)jarg1;
59398   {
59399     try {
59400       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
59401     } catch (std::out_of_range& e) {
59402       {
59403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59404       };
59405     } catch (std::exception& e) {
59406       {
59407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59408       };
59409     } catch (Dali::DaliException e) {
59410       {
59411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59412       };
59413     } catch (...) {
59414       {
59415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59416       };
59417     }
59418   }
59419
59420   jresult = result;
59421   return jresult;
59422 }
59423
59424
59425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
59426   void * jresult ;
59427   Dali::Signal< bool () > *result = 0 ;
59428
59429   {
59430     try {
59431       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
59432     } catch (std::out_of_range& e) {
59433       {
59434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59435       };
59436     } catch (std::exception& e) {
59437       {
59438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59439       };
59440     } catch (Dali::DaliException e) {
59441       {
59442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59443       };
59444     } catch (...) {
59445       {
59446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59447       };
59448     }
59449   }
59450
59451   jresult = (void *)result;
59452   return jresult;
59453 }
59454
59455
59456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
59457   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
59458
59459   arg1 = (Dali::Signal< bool () > *)jarg1;
59460   {
59461     try {
59462       delete arg1;
59463     } catch (std::out_of_range& e) {
59464       {
59465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59466       };
59467     } catch (std::exception& e) {
59468       {
59469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59470       };
59471     } catch (Dali::DaliException e) {
59472       {
59473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59474       };
59475     } catch (...) {
59476       {
59477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59478       };
59479     }
59480   }
59481
59482 }
59483
59484
59485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59486   int jresult ;
59487   int result;
59488
59489   {
59490     try {
59491       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59492     } catch (std::out_of_range& e) {
59493       {
59494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59495       };
59496     } catch (std::exception& e) {
59497       {
59498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59499       };
59500     } catch (Dali::DaliException e) {
59501       {
59502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59503       };
59504     } catch (...) {
59505       {
59506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59507       };
59508     }
59509   }
59510
59511   jresult = (int)result;
59512   return jresult;
59513 }
59514
59515
59516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59517   int jresult ;
59518   int result;
59519
59520   {
59521     try {
59522       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59523     } catch (std::out_of_range& e) {
59524       {
59525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59526       };
59527     } catch (std::exception& e) {
59528       {
59529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59530       };
59531     } catch (Dali::DaliException e) {
59532       {
59533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59534       };
59535     } catch (...) {
59536       {
59537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59538       };
59539     }
59540   }
59541
59542   jresult = (int)result;
59543   return jresult;
59544 }
59545
59546
59547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59548   int jresult ;
59549   int result;
59550
59551   {
59552     try {
59553       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59554     } catch (std::out_of_range& e) {
59555       {
59556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59557       };
59558     } catch (std::exception& e) {
59559       {
59560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59561       };
59562     } catch (Dali::DaliException e) {
59563       {
59564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59565       };
59566     } catch (...) {
59567       {
59568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59569       };
59570     }
59571   }
59572
59573   jresult = (int)result;
59574   return jresult;
59575 }
59576
59577
59578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59579   int jresult ;
59580   int result;
59581
59582   {
59583     try {
59584       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59585     } catch (std::out_of_range& e) {
59586       {
59587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59588       };
59589     } catch (std::exception& e) {
59590       {
59591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59592       };
59593     } catch (Dali::DaliException e) {
59594       {
59595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59596       };
59597     } catch (...) {
59598       {
59599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59600       };
59601     }
59602   }
59603
59604   jresult = (int)result;
59605   return jresult;
59606 }
59607
59608
59609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59610   int jresult ;
59611   int result;
59612
59613   {
59614     try {
59615       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59616     } catch (std::out_of_range& e) {
59617       {
59618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59619       };
59620     } catch (std::exception& e) {
59621       {
59622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59623       };
59624     } catch (Dali::DaliException e) {
59625       {
59626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59627       };
59628     } catch (...) {
59629       {
59630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59631       };
59632     }
59633   }
59634
59635   jresult = (int)result;
59636   return jresult;
59637 }
59638
59639
59640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59641   int jresult ;
59642   int result;
59643
59644   {
59645     try {
59646       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59647     } catch (std::out_of_range& e) {
59648       {
59649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59650       };
59651     } catch (std::exception& e) {
59652       {
59653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59654       };
59655     } catch (Dali::DaliException e) {
59656       {
59657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59658       };
59659     } catch (...) {
59660       {
59661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59662       };
59663     }
59664   }
59665
59666   jresult = (int)result;
59667   return jresult;
59668 }
59669
59670
59671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59672   int jresult ;
59673   int result;
59674
59675   {
59676     try {
59677       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59678     } catch (std::out_of_range& e) {
59679       {
59680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59681       };
59682     } catch (std::exception& e) {
59683       {
59684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (Dali::DaliException e) {
59687       {
59688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59689       };
59690     } catch (...) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59693       };
59694     }
59695   }
59696
59697   jresult = (int)result;
59698   return jresult;
59699 }
59700
59701
59702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59703   int jresult ;
59704   int result;
59705
59706   {
59707     try {
59708       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59709     } catch (std::out_of_range& e) {
59710       {
59711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59712       };
59713     } catch (std::exception& e) {
59714       {
59715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59716       };
59717     } catch (Dali::DaliException e) {
59718       {
59719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59720       };
59721     } catch (...) {
59722       {
59723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59724       };
59725     }
59726   }
59727
59728   jresult = (int)result;
59729   return jresult;
59730 }
59731
59732
59733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59734   int jresult ;
59735   int result;
59736
59737   {
59738     try {
59739       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59740     } catch (std::out_of_range& e) {
59741       {
59742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59743       };
59744     } catch (std::exception& e) {
59745       {
59746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59747       };
59748     } catch (Dali::DaliException e) {
59749       {
59750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59751       };
59752     } catch (...) {
59753       {
59754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59755       };
59756     }
59757   }
59758
59759   jresult = (int)result;
59760   return jresult;
59761 }
59762
59763
59764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59765   int jresult ;
59766   int result;
59767
59768   {
59769     try {
59770       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59771     } catch (std::out_of_range& e) {
59772       {
59773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59774       };
59775     } catch (std::exception& e) {
59776       {
59777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59778       };
59779     } catch (Dali::DaliException e) {
59780       {
59781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59782       };
59783     } catch (...) {
59784       {
59785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59786       };
59787     }
59788   }
59789
59790   jresult = (int)result;
59791   return jresult;
59792 }
59793
59794
59795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59796   int jresult ;
59797   int result;
59798
59799   {
59800     try {
59801       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59802     } catch (std::out_of_range& e) {
59803       {
59804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59805       };
59806     } catch (std::exception& e) {
59807       {
59808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59809       };
59810     } catch (Dali::DaliException e) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59813       };
59814     } catch (...) {
59815       {
59816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59817       };
59818     }
59819   }
59820
59821   jresult = (int)result;
59822   return jresult;
59823 }
59824
59825
59826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59827   int jresult ;
59828   int result;
59829
59830   {
59831     try {
59832       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59833     } catch (std::out_of_range& e) {
59834       {
59835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59836       };
59837     } catch (std::exception& e) {
59838       {
59839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59840       };
59841     } catch (Dali::DaliException e) {
59842       {
59843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59844       };
59845     } catch (...) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59848       };
59849     }
59850   }
59851
59852   jresult = (int)result;
59853   return jresult;
59854 }
59855
59856
59857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59858   int jresult ;
59859   int result;
59860
59861   {
59862     try {
59863       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59864     } catch (std::out_of_range& e) {
59865       {
59866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59867       };
59868     } catch (std::exception& e) {
59869       {
59870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59871       };
59872     } catch (Dali::DaliException e) {
59873       {
59874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59875       };
59876     } catch (...) {
59877       {
59878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59879       };
59880     }
59881   }
59882
59883   jresult = (int)result;
59884   return jresult;
59885 }
59886
59887
59888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59889   int jresult ;
59890   int result;
59891
59892   {
59893     try {
59894       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59895     } catch (std::out_of_range& e) {
59896       {
59897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59898       };
59899     } catch (std::exception& e) {
59900       {
59901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59902       };
59903     } catch (Dali::DaliException e) {
59904       {
59905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59906       };
59907     } catch (...) {
59908       {
59909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59910       };
59911     }
59912   }
59913
59914   jresult = (int)result;
59915   return jresult;
59916 }
59917
59918
59919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59920   int jresult ;
59921   int result;
59922
59923   {
59924     try {
59925       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59933       };
59934     } catch (Dali::DaliException e) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59937       };
59938     } catch (...) {
59939       {
59940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59941       };
59942     }
59943   }
59944
59945   jresult = (int)result;
59946   return jresult;
59947 }
59948
59949
59950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59951   int jresult ;
59952   int result;
59953
59954   {
59955     try {
59956       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59957     } catch (std::out_of_range& e) {
59958       {
59959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59960       };
59961     } catch (std::exception& e) {
59962       {
59963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59964       };
59965     } catch (Dali::DaliException e) {
59966       {
59967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59968       };
59969     } catch (...) {
59970       {
59971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59972       };
59973     }
59974   }
59975
59976   jresult = (int)result;
59977   return jresult;
59978 }
59979
59980
59981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59982   int jresult ;
59983   int result;
59984
59985   {
59986     try {
59987       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59988     } catch (std::out_of_range& e) {
59989       {
59990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59991       };
59992     } catch (std::exception& e) {
59993       {
59994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59995       };
59996     } catch (Dali::DaliException e) {
59997       {
59998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59999       };
60000     } catch (...) {
60001       {
60002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60003       };
60004     }
60005   }
60006
60007   jresult = (int)result;
60008   return jresult;
60009 }
60010
60011
60012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
60013   int jresult ;
60014   int result;
60015
60016   {
60017     try {
60018       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
60019     } catch (std::out_of_range& e) {
60020       {
60021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60022       };
60023     } catch (std::exception& e) {
60024       {
60025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60026       };
60027     } catch (Dali::DaliException e) {
60028       {
60029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60030       };
60031     } catch (...) {
60032       {
60033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60034       };
60035     }
60036   }
60037
60038   jresult = (int)result;
60039   return jresult;
60040 }
60041
60042
60043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
60044   int jresult ;
60045   int result;
60046
60047   {
60048     try {
60049       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
60050     } catch (std::out_of_range& e) {
60051       {
60052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60053       };
60054     } catch (std::exception& e) {
60055       {
60056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60057       };
60058     } catch (Dali::DaliException e) {
60059       {
60060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60061       };
60062     } catch (...) {
60063       {
60064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60065       };
60066     }
60067   }
60068
60069   jresult = (int)result;
60070   return jresult;
60071 }
60072
60073
60074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
60075   int jresult ;
60076   int result;
60077
60078   {
60079     try {
60080       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
60081     } catch (std::out_of_range& e) {
60082       {
60083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60084       };
60085     } catch (std::exception& e) {
60086       {
60087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60088       };
60089     } catch (Dali::DaliException e) {
60090       {
60091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60092       };
60093     } catch (...) {
60094       {
60095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60096       };
60097     }
60098   }
60099
60100   jresult = (int)result;
60101   return jresult;
60102 }
60103
60104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
60105   int jresult ;
60106   int result;
60107
60108   {
60109     try {
60110       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
60111     } catch (std::out_of_range& e) {
60112       {
60113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60114       };
60115     } catch (std::exception& e) {
60116       {
60117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60118       };
60119     } catch (Dali::DaliException e) {
60120       {
60121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60122       };
60123     } catch (...) {
60124       {
60125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60126       };
60127     }
60128   }
60129
60130   jresult = (int)result;
60131   return jresult;
60132 }
60133
60134
60135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
60136   int jresult ;
60137   int result;
60138   {
60139     try
60140     {
60141       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
60142     } catch (std::out_of_range& e) {
60143       {
60144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60145       };
60146     } catch (std::exception& e) {
60147       {
60148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60149       };
60150     } catch (Dali::DaliException e) {
60151       {
60152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60153       };
60154     } catch (...) {
60155       {
60156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60157       };
60158     }
60159   }
60160
60161   jresult = (int)result;
60162   return jresult;
60163 }
60164
60165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
60166   int jresult ;
60167   int result;
60168   {
60169     try
60170     {
60171       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
60172     } catch (std::out_of_range& e) {
60173       {
60174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60175       };
60176     } catch (std::exception& e) {
60177       {
60178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60179       };
60180     } catch (Dali::DaliException e) {
60181       {
60182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60183       };
60184     } catch (...) {
60185       {
60186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60187       };
60188     }
60189   }
60190
60191   jresult = (int)result;
60192   return jresult;
60193 }
60194
60195 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
60196   int jresult ;
60197   int result;
60198   {
60199     try
60200     {
60201       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
60202     } catch (std::out_of_range& e) {
60203       {
60204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60205       };
60206     } catch (std::exception& e) {
60207       {
60208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (Dali::DaliException e) {
60211       {
60212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60213       };
60214     } catch (...) {
60215       {
60216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60217       };
60218     }
60219   }
60220
60221   jresult = (int)result;
60222   return jresult;
60223 }
60224
60225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
60226   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
60227 }
60228
60229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
60230   int jresult ;
60231   int result;
60232   {
60233     try
60234     {
60235       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
60236     } catch (std::out_of_range& e) {
60237       {
60238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60239       };
60240     } catch (std::exception& e) {
60241       {
60242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60243       };
60244     } catch (Dali::DaliException e) {
60245       {
60246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60247       };
60248     } catch (...) {
60249       {
60250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60251       };
60252     }
60253   }
60254
60255   jresult = (int)result;
60256   return jresult;
60257 }
60258
60259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
60260   int jresult ;
60261   int result;
60262   {
60263     try
60264     {
60265       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
60266     } catch (std::out_of_range& e) {
60267       {
60268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60269       };
60270     } catch (std::exception& e) {
60271       {
60272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60273       };
60274     } catch (Dali::DaliException e) {
60275       {
60276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60277       };
60278     } catch (...) {
60279       {
60280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60281       };
60282     }
60283   }
60284
60285   jresult = (int)result;
60286   return jresult;
60287 }
60288
60289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
60290   int jresult ;
60291   int result;
60292
60293   {
60294     try {
60295       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60303       };
60304     } catch (Dali::DaliException e) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60307       };
60308     } catch (...) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60311       };
60312     }
60313   }
60314
60315   jresult = (int)result;
60316   return jresult;
60317 }
60318
60319
60320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
60321   int jresult ;
60322   int result;
60323
60324   {
60325     try {
60326       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
60327     } catch (std::out_of_range& e) {
60328       {
60329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60330       };
60331     } catch (std::exception& e) {
60332       {
60333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60334       };
60335     } catch (Dali::DaliException e) {
60336       {
60337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60338       };
60339     } catch (...) {
60340       {
60341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60342       };
60343     }
60344   }
60345
60346   jresult = (int)result;
60347   return jresult;
60348 }
60349
60350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
60351   int jresult ;
60352   int result;
60353   {
60354     try
60355     {
60356       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
60357     } catch (std::out_of_range& e) {
60358       {
60359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60360       };
60361     } catch (std::exception& e) {
60362       {
60363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60364       };
60365     } catch (...) {
60366       {
60367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60368       };
60369     }
60370   }
60371   jresult = (int)result;
60372   return jresult;
60373 }
60374
60375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
60376   int jresult ;
60377   int result;
60378   {
60379     try
60380     {
60381       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
60382     } catch (std::out_of_range& e) {
60383       {
60384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60385       };
60386     } catch (std::exception& e) {
60387       {
60388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60389       };
60390     } catch (...) {
60391       {
60392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60393       };
60394     }
60395   }
60396   jresult = (int)result;
60397   return jresult;
60398 }
60399
60400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
60401   int jresult ;
60402   int result;
60403   {
60404     try
60405     {
60406       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
60407     } catch (std::out_of_range& e) {
60408       {
60409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60410       };
60411     } catch (std::exception& e) {
60412       {
60413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60414       };
60415     } catch (...) {
60416       {
60417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60418       };
60419     }
60420   }
60421   jresult = (int)result;
60422   return jresult;
60423 }
60424
60425
60426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
60427   int jresult ;
60428   int result;
60429   {
60430     try
60431     {
60432       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
60433     } catch (std::out_of_range& e) {
60434       {
60435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60436       };
60437     } catch (std::exception& e) {
60438       {
60439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60440       };
60441     } catch (...) {
60442       {
60443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60444       };
60445     }
60446   }
60447   jresult = (int)result;
60448   return jresult;
60449 }
60450
60451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
60452   int jresult ;
60453   int result;
60454   {
60455     try
60456     {
60457       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
60458     } catch (std::out_of_range& e) {
60459       {
60460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (std::exception& e) {
60463       {
60464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (...) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60469       };
60470     }
60471   }
60472   jresult = (int)result;
60473   return jresult;
60474 }
60475
60476
60477
60478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
60479   int jresult ;
60480   int result;
60481
60482   {
60483     try {
60484       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60485     } catch (std::out_of_range& e) {
60486       {
60487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (std::exception& e) {
60490       {
60491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (Dali::DaliException e) {
60494       {
60495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60500       };
60501     }
60502   }
60503
60504   jresult = (int)result;
60505   return jresult;
60506 }
60507
60508
60509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60510   int jresult ;
60511   int result;
60512
60513   {
60514     try {
60515       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (Dali::DaliException e) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60527       };
60528     } catch (...) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60531       };
60532     }
60533   }
60534
60535   jresult = (int)result;
60536   return jresult;
60537 }
60538
60539
60540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60541   int jresult ;
60542   int result;
60543
60544   {
60545     try {
60546       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60547     } catch (std::out_of_range& e) {
60548       {
60549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60550       };
60551     } catch (std::exception& e) {
60552       {
60553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (Dali::DaliException e) {
60556       {
60557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60558       };
60559     } catch (...) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60562       };
60563     }
60564   }
60565
60566   jresult = (int)result;
60567   return jresult;
60568 }
60569
60570
60571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60572   int jresult ;
60573   int result;
60574
60575   {
60576     try {
60577       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60578     } catch (std::out_of_range& e) {
60579       {
60580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60581       };
60582     } catch (std::exception& e) {
60583       {
60584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (Dali::DaliException e) {
60587       {
60588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60593       };
60594     }
60595   }
60596
60597   jresult = (int)result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60603   int jresult ;
60604   int result;
60605
60606   {
60607     try {
60608       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (Dali::DaliException e) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60620       };
60621     } catch (...) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60624       };
60625     }
60626   }
60627
60628   jresult = (int)result;
60629   return jresult;
60630 }
60631
60632
60633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60634   int jresult ;
60635   int result;
60636
60637   {
60638     try {
60639       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60640     } catch (std::out_of_range& e) {
60641       {
60642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60643       };
60644     } catch (std::exception& e) {
60645       {
60646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (Dali::DaliException e) {
60649       {
60650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60651       };
60652     } catch (...) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60655       };
60656     }
60657   }
60658
60659   jresult = (int)result;
60660   return jresult;
60661 }
60662
60663
60664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60665   int jresult ;
60666   int result;
60667
60668   {
60669     try {
60670       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60671     } catch (std::out_of_range& e) {
60672       {
60673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (std::exception& e) {
60676       {
60677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (Dali::DaliException e) {
60680       {
60681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60686       };
60687     }
60688   }
60689
60690   jresult = (int)result;
60691   return jresult;
60692 }
60693
60694 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60695   int jresult ;
60696   int result;
60697
60698   {
60699     try {
60700       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60701     } catch (std::out_of_range& e) {
60702       {
60703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60704       };
60705     } catch (std::exception& e) {
60706       {
60707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60708       };
60709     } catch (...) {
60710       {
60711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60712       };
60713     }
60714   }
60715   jresult = (int)result;
60716   return jresult;
60717 }
60718
60719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60720   int jresult ;
60721   int result;
60722
60723   {
60724     try {
60725       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60726     } catch (std::out_of_range& e) {
60727       {
60728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60729       };
60730     } catch (std::exception& e) {
60731       {
60732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60733       };
60734     } catch (Dali::DaliException e) {
60735       {
60736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60737       };
60738     } catch (...) {
60739       {
60740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60741       };
60742     }
60743   }
60744
60745   jresult = (int)result;
60746   return jresult;
60747 }
60748
60749
60750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60751   int jresult ;
60752   int result;
60753
60754   {
60755     try {
60756       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60757     } catch (std::out_of_range& e) {
60758       {
60759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60760       };
60761     } catch (std::exception& e) {
60762       {
60763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60764       };
60765     } catch (Dali::DaliException e) {
60766       {
60767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60768       };
60769     } catch (...) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60772       };
60773     }
60774   }
60775
60776   jresult = (int)result;
60777   return jresult;
60778 }
60779
60780
60781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60782   int jresult ;
60783   int result;
60784
60785   {
60786     try {
60787       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60788     } catch (std::out_of_range& e) {
60789       {
60790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60791       };
60792     } catch (std::exception& e) {
60793       {
60794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60795       };
60796     } catch (Dali::DaliException e) {
60797       {
60798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60799       };
60800     } catch (...) {
60801       {
60802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60803       };
60804     }
60805   }
60806
60807   jresult = (int)result;
60808   return jresult;
60809 }
60810
60811
60812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60813   int jresult ;
60814   int result;
60815
60816   {
60817     try {
60818       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60819     } catch (std::out_of_range& e) {
60820       {
60821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60822       };
60823     } catch (std::exception& e) {
60824       {
60825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60826       };
60827     } catch (Dali::DaliException e) {
60828       {
60829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60830       };
60831     } catch (...) {
60832       {
60833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60834       };
60835     }
60836   }
60837
60838   jresult = (int)result;
60839   return jresult;
60840 }
60841
60842
60843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60844   int jresult ;
60845   int result;
60846
60847   {
60848     try {
60849       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60850     } catch (std::out_of_range& e) {
60851       {
60852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60853       };
60854     } catch (std::exception& e) {
60855       {
60856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60857       };
60858     } catch (Dali::DaliException e) {
60859       {
60860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60861       };
60862     } catch (...) {
60863       {
60864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60865       };
60866     }
60867   }
60868
60869   jresult = (int)result;
60870   return jresult;
60871 }
60872
60873
60874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60875   int jresult ;
60876   int result;
60877
60878   {
60879     try {
60880       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60881     } catch (std::out_of_range& e) {
60882       {
60883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60884       };
60885     } catch (std::exception& e) {
60886       {
60887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (Dali::DaliException e) {
60890       {
60891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60892       };
60893     } catch (...) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60896       };
60897     }
60898   }
60899
60900   jresult = (int)result;
60901   return jresult;
60902 }
60903
60904
60905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60906   int jresult ;
60907   int result;
60908
60909   {
60910     try {
60911       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60912     } catch (std::out_of_range& e) {
60913       {
60914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60915       };
60916     } catch (std::exception& e) {
60917       {
60918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60919       };
60920     } catch (Dali::DaliException e) {
60921       {
60922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60923       };
60924     } catch (...) {
60925       {
60926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60927       };
60928     }
60929   }
60930
60931   jresult = (int)result;
60932   return jresult;
60933 }
60934
60935
60936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60937   int jresult ;
60938   int result;
60939
60940   {
60941     try {
60942       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60943     } catch (std::out_of_range& e) {
60944       {
60945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60946       };
60947     } catch (std::exception& e) {
60948       {
60949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60950       };
60951     } catch (Dali::DaliException e) {
60952       {
60953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60954       };
60955     } catch (...) {
60956       {
60957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60958       };
60959     }
60960   }
60961
60962   jresult = (int)result;
60963   return jresult;
60964 }
60965
60966
60967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60968   int jresult ;
60969   int result;
60970
60971   {
60972     try {
60973       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60974     } catch (std::out_of_range& e) {
60975       {
60976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60977       };
60978     } catch (std::exception& e) {
60979       {
60980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60981       };
60982     } catch (Dali::DaliException e) {
60983       {
60984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60985       };
60986     } catch (...) {
60987       {
60988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60989       };
60990     }
60991   }
60992
60993   jresult = (int)result;
60994   return jresult;
60995 }
60996
60997
60998 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60999   int jresult ;
61000   int result;
61001
61002   {
61003     try {
61004       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
61005     } catch (std::out_of_range& e) {
61006       {
61007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61008       };
61009     } catch (std::exception& e) {
61010       {
61011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (Dali::DaliException e) {
61014       {
61015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61016       };
61017     } catch (...) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61020       };
61021     }
61022   }
61023
61024   jresult = (int)result;
61025   return jresult;
61026 }
61027
61028
61029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
61030   int jresult ;
61031   int result;
61032
61033   {
61034     try {
61035       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
61036     } catch (std::out_of_range& e) {
61037       {
61038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61039       };
61040     } catch (std::exception& e) {
61041       {
61042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61043       };
61044     } catch (Dali::DaliException e) {
61045       {
61046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61047       };
61048     } catch (...) {
61049       {
61050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61051       };
61052     }
61053   }
61054
61055   jresult = (int)result;
61056   return jresult;
61057 }
61058
61059
61060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
61061   int jresult ;
61062   int result;
61063
61064   {
61065     try {
61066       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
61067     } catch (std::out_of_range& e) {
61068       {
61069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61070       };
61071     } catch (std::exception& e) {
61072       {
61073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61074       };
61075     } catch (Dali::DaliException e) {
61076       {
61077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61078       };
61079     } catch (...) {
61080       {
61081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61082       };
61083     }
61084   }
61085
61086   jresult = (int)result;
61087   return jresult;
61088 }
61089
61090
61091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
61092   int jresult ;
61093   int result;
61094
61095   {
61096     try {
61097       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
61098     } catch (std::out_of_range& e) {
61099       {
61100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61101       };
61102     } catch (std::exception& e) {
61103       {
61104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61105       };
61106     } catch (Dali::DaliException e) {
61107       {
61108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61109       };
61110     } catch (...) {
61111       {
61112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61113       };
61114     }
61115   }
61116
61117   jresult = (int)result;
61118   return jresult;
61119 }
61120
61121
61122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
61123   int jresult ;
61124   int result;
61125
61126   {
61127     try {
61128       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
61129     } catch (std::out_of_range& e) {
61130       {
61131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61132       };
61133     } catch (std::exception& e) {
61134       {
61135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61136       };
61137     } catch (Dali::DaliException e) {
61138       {
61139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61140       };
61141     } catch (...) {
61142       {
61143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61144       };
61145     }
61146   }
61147
61148   jresult = (int)result;
61149   return jresult;
61150 }
61151
61152
61153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
61154   int jresult ;
61155   int result;
61156
61157   {
61158     try {
61159       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
61160     } catch (std::out_of_range& e) {
61161       {
61162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61163       };
61164     } catch (std::exception& e) {
61165       {
61166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61167       };
61168     } catch (Dali::DaliException e) {
61169       {
61170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61171       };
61172     } catch (...) {
61173       {
61174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61175       };
61176     }
61177   }
61178
61179   jresult = (int)result;
61180   return jresult;
61181 }
61182
61183
61184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
61185   int jresult ;
61186   int result;
61187
61188   {
61189     try {
61190       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
61191     } catch (std::out_of_range& e) {
61192       {
61193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61194       };
61195     } catch (std::exception& e) {
61196       {
61197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61198       };
61199     } catch (Dali::DaliException e) {
61200       {
61201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61202       };
61203     } catch (...) {
61204       {
61205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61206       };
61207     }
61208   }
61209
61210   jresult = (int)result;
61211   return jresult;
61212 }
61213
61214
61215 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
61216   int jresult ;
61217   int result;
61218
61219   {
61220     try {
61221       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
61222     } catch (std::out_of_range& e) {
61223       {
61224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61225       };
61226     } catch (std::exception& e) {
61227       {
61228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61229       };
61230     } catch (Dali::DaliException e) {
61231       {
61232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61233       };
61234     } catch (...) {
61235       {
61236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61237       };
61238     }
61239   }
61240
61241   jresult = (int)result;
61242   return jresult;
61243 }
61244
61245
61246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
61247   int jresult ;
61248   int result;
61249
61250   {
61251     try {
61252       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
61253     } catch (std::out_of_range& e) {
61254       {
61255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61256       };
61257     } catch (std::exception& e) {
61258       {
61259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61260       };
61261     } catch (Dali::DaliException e) {
61262       {
61263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61264       };
61265     } catch (...) {
61266       {
61267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61268       };
61269     }
61270   }
61271
61272   jresult = (int)result;
61273   return jresult;
61274 }
61275
61276
61277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
61278   int jresult ;
61279   int result;
61280
61281   {
61282     try {
61283       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
61284     } catch (std::out_of_range& e) {
61285       {
61286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61287       };
61288     } catch (std::exception& e) {
61289       {
61290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61291       };
61292     } catch (Dali::DaliException e) {
61293       {
61294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61295       };
61296     } catch (...) {
61297       {
61298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61299       };
61300     }
61301   }
61302
61303   jresult = (int)result;
61304   return jresult;
61305 }
61306
61307
61308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
61309   int jresult ;
61310   int result;
61311
61312   {
61313     try {
61314       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
61315     } catch (std::out_of_range& e) {
61316       {
61317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61318       };
61319     } catch (std::exception& e) {
61320       {
61321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61322       };
61323     } catch (Dali::DaliException e) {
61324       {
61325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61326       };
61327     } catch (...) {
61328       {
61329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61330       };
61331     }
61332   }
61333
61334   jresult = (int)result;
61335   return jresult;
61336 }
61337
61338
61339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
61340   int jresult ;
61341   int result;
61342
61343   {
61344     try {
61345       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
61346     } catch (std::out_of_range& e) {
61347       {
61348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61349       };
61350     } catch (std::exception& e) {
61351       {
61352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61353       };
61354     } catch (Dali::DaliException e) {
61355       {
61356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61357       };
61358     } catch (...) {
61359       {
61360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61361       };
61362     }
61363   }
61364
61365   jresult = (int)result;
61366   return jresult;
61367 }
61368
61369
61370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
61371   int jresult ;
61372   int result;
61373
61374   {
61375     try {
61376       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
61377     } catch (std::out_of_range& e) {
61378       {
61379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61380       };
61381     } catch (std::exception& e) {
61382       {
61383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61384       };
61385     } catch (Dali::DaliException e) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61392       };
61393     }
61394   }
61395
61396   jresult = (int)result;
61397   return jresult;
61398 }
61399
61400
61401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
61402   int jresult ;
61403   int result;
61404
61405   {
61406     try {
61407       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
61408     } catch (std::out_of_range& e) {
61409       {
61410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61411       };
61412     } catch (std::exception& e) {
61413       {
61414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61415       };
61416     } catch (Dali::DaliException e) {
61417       {
61418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61419       };
61420     } catch (...) {
61421       {
61422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61423       };
61424     }
61425   }
61426
61427   jresult = (int)result;
61428   return jresult;
61429 }
61430
61431
61432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
61433   int jresult ;
61434   int result;
61435
61436   {
61437     try {
61438       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
61439     } catch (std::out_of_range& e) {
61440       {
61441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61442       };
61443     } catch (std::exception& e) {
61444       {
61445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61446       };
61447     } catch (Dali::DaliException e) {
61448       {
61449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61450       };
61451     } catch (...) {
61452       {
61453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61454       };
61455     }
61456   }
61457
61458   jresult = (int)result;
61459   return jresult;
61460 }
61461
61462
61463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
61464   int jresult ;
61465   int result;
61466
61467   {
61468     try {
61469       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
61470     } catch (std::out_of_range& e) {
61471       {
61472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61473       };
61474     } catch (std::exception& e) {
61475       {
61476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61477       };
61478     } catch (Dali::DaliException e) {
61479       {
61480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61481       };
61482     } catch (...) {
61483       {
61484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61485       };
61486     }
61487   }
61488
61489   jresult = (int)result;
61490   return jresult;
61491 }
61492
61493
61494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61495   int jresult ;
61496   int result;
61497
61498   {
61499     try {
61500       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61501     } catch (std::out_of_range& e) {
61502       {
61503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61504       };
61505     } catch (std::exception& e) {
61506       {
61507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61508       };
61509     } catch (Dali::DaliException e) {
61510       {
61511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61512       };
61513     } catch (...) {
61514       {
61515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61516       };
61517     }
61518   }
61519
61520   jresult = (int)result;
61521   return jresult;
61522 }
61523
61524
61525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61526   int jresult ;
61527   int result;
61528
61529   {
61530     try {
61531       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61532     } catch (std::out_of_range& e) {
61533       {
61534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61535       };
61536     } catch (std::exception& e) {
61537       {
61538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61539       };
61540     } catch (Dali::DaliException e) {
61541       {
61542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61543       };
61544     } catch (...) {
61545       {
61546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61547       };
61548     }
61549   }
61550
61551   jresult = (int)result;
61552   return jresult;
61553 }
61554
61555
61556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61557   int jresult ;
61558   int result;
61559
61560   {
61561     try {
61562       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61563     } catch (std::out_of_range& e) {
61564       {
61565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61566       };
61567     } catch (std::exception& e) {
61568       {
61569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61570       };
61571     } catch (Dali::DaliException e) {
61572       {
61573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61574       };
61575     } catch (...) {
61576       {
61577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61578       };
61579     }
61580   }
61581
61582   jresult = (int)result;
61583   return jresult;
61584 }
61585
61586
61587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61588   void * jresult ;
61589   Dali::Toolkit::Builder *result = 0 ;
61590
61591   {
61592     try {
61593       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61594     } catch (std::out_of_range& e) {
61595       {
61596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61597       };
61598     } catch (std::exception& e) {
61599       {
61600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61601       };
61602     } catch (Dali::DaliException e) {
61603       {
61604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61605       };
61606     } catch (...) {
61607       {
61608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61609       };
61610     }
61611   }
61612
61613   jresult = (void *)result;
61614   return jresult;
61615 }
61616
61617
61618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61619   void * jresult ;
61620   Dali::Toolkit::Builder result;
61621
61622   {
61623     try {
61624       result = Dali::Toolkit::Builder::New();
61625     } catch (std::out_of_range& e) {
61626       {
61627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61628       };
61629     } catch (std::exception& e) {
61630       {
61631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61632       };
61633     } catch (Dali::DaliException e) {
61634       {
61635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61636       };
61637     } catch (...) {
61638       {
61639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61640       };
61641     }
61642   }
61643
61644   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61645   return jresult;
61646 }
61647
61648
61649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61650   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61651
61652   arg1 = (Dali::Toolkit::Builder *)jarg1;
61653   {
61654     try {
61655       delete arg1;
61656     } catch (std::out_of_range& e) {
61657       {
61658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61659       };
61660     } catch (std::exception& e) {
61661       {
61662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61663       };
61664     } catch (Dali::DaliException e) {
61665       {
61666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61667       };
61668     } catch (...) {
61669       {
61670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61671       };
61672     }
61673   }
61674
61675 }
61676
61677
61678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61679   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61680   std::string *arg2 = 0 ;
61681   Dali::Toolkit::Builder::UIFormat arg3 ;
61682
61683   arg1 = (Dali::Toolkit::Builder *)jarg1;
61684   if (!jarg2) {
61685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61686     return ;
61687   }
61688   std::string arg2_str(jarg2);
61689   arg2 = &arg2_str;
61690   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61691   {
61692     try {
61693       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61694     } catch (std::out_of_range& e) {
61695       {
61696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61697       };
61698     } catch (std::exception& e) {
61699       {
61700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61701       };
61702     } catch (Dali::DaliException e) {
61703       {
61704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61705       };
61706     } catch (...) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61709       };
61710     }
61711   }
61712
61713
61714   //argout typemap for const std::string&
61715
61716 }
61717
61718
61719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61720   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61721   std::string *arg2 = 0 ;
61722
61723   arg1 = (Dali::Toolkit::Builder *)jarg1;
61724   if (!jarg2) {
61725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61726     return ;
61727   }
61728   std::string arg2_str(jarg2);
61729   arg2 = &arg2_str;
61730   {
61731     try {
61732       (arg1)->LoadFromString((std::string const &)*arg2);
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61748       };
61749     }
61750   }
61751
61752
61753   //argout typemap for const std::string&
61754
61755 }
61756
61757
61758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61759   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61760   Dali::Property::Map *arg2 = 0 ;
61761
61762   arg1 = (Dali::Toolkit::Builder *)jarg1;
61763   arg2 = (Dali::Property::Map *)jarg2;
61764   if (!arg2) {
61765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61766     return ;
61767   }
61768   {
61769     try {
61770       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61771     } catch (std::out_of_range& e) {
61772       {
61773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61774       };
61775     } catch (std::exception& e) {
61776       {
61777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61778       };
61779     } catch (Dali::DaliException e) {
61780       {
61781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61782       };
61783     } catch (...) {
61784       {
61785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61786       };
61787     }
61788   }
61789
61790 }
61791
61792
61793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61794   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61795   std::string *arg2 = 0 ;
61796   Dali::Property::Value *arg3 = 0 ;
61797
61798   arg1 = (Dali::Toolkit::Builder *)jarg1;
61799   if (!jarg2) {
61800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61801     return ;
61802   }
61803   std::string arg2_str(jarg2);
61804   arg2 = &arg2_str;
61805   arg3 = (Dali::Property::Value *)jarg3;
61806   if (!arg3) {
61807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61808     return ;
61809   }
61810   {
61811     try {
61812       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61820       };
61821     } catch (Dali::DaliException e) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61824       };
61825     } catch (...) {
61826       {
61827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61828       };
61829     }
61830   }
61831
61832
61833   //argout typemap for const std::string&
61834
61835 }
61836
61837
61838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61839   void * jresult ;
61840   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61841   Dali::Property::Map *result = 0 ;
61842
61843   arg1 = (Dali::Toolkit::Builder *)jarg1;
61844   {
61845     try {
61846       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61847     } catch (std::out_of_range& e) {
61848       {
61849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61850       };
61851     } catch (std::exception& e) {
61852       {
61853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61854       };
61855     } catch (Dali::DaliException e) {
61856       {
61857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61858       };
61859     } catch (...) {
61860       {
61861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61862       };
61863     }
61864   }
61865
61866   jresult = (void *)result;
61867   return jresult;
61868 }
61869
61870
61871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61872   void * jresult ;
61873   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61874   std::string *arg2 = 0 ;
61875   Dali::Property::Value *result = 0 ;
61876
61877   arg1 = (Dali::Toolkit::Builder *)jarg1;
61878   if (!jarg2) {
61879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61880     return 0;
61881   }
61882   std::string arg2_str(jarg2);
61883   arg2 = &arg2_str;
61884   {
61885     try {
61886       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905
61906   jresult = (void *)result;
61907
61908   //argout typemap for const std::string&
61909
61910   return jresult;
61911 }
61912
61913
61914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61915   void * jresult ;
61916   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61917   std::string *arg2 = 0 ;
61918   Dali::Animation result;
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 = (arg1)->CreateAnimation((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 = new Dali::Animation((const Dali::Animation &)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_1(void * jarg1, char * jarg2, void * jarg3) {
61958   void * jresult ;
61959   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61960   std::string *arg2 = 0 ;
61961   Dali::Property::Map *arg3 = 0 ;
61962   Dali::Animation result;
61963
61964   arg1 = (Dali::Toolkit::Builder *)jarg1;
61965   if (!jarg2) {
61966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61967     return 0;
61968   }
61969   std::string arg2_str(jarg2);
61970   arg2 = &arg2_str;
61971   arg3 = (Dali::Property::Map *)jarg3;
61972   if (!arg3) {
61973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61974     return 0;
61975   }
61976   {
61977     try {
61978       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61979     } catch (std::out_of_range& e) {
61980       {
61981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61982       };
61983     } catch (std::exception& e) {
61984       {
61985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61986       };
61987     } catch (Dali::DaliException e) {
61988       {
61989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61990       };
61991     } catch (...) {
61992       {
61993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61994       };
61995     }
61996   }
61997
61998   jresult = new Dali::Animation((const Dali::Animation &)result);
61999
62000   //argout typemap for const std::string&
62001
62002   return jresult;
62003 }
62004
62005
62006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
62007   void * jresult ;
62008   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62009   std::string *arg2 = 0 ;
62010   Dali::Actor arg3 ;
62011   Dali::Actor *argp3 ;
62012   Dali::Animation result;
62013
62014   arg1 = (Dali::Toolkit::Builder *)jarg1;
62015   if (!jarg2) {
62016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62017     return 0;
62018   }
62019   std::string arg2_str(jarg2);
62020   arg2 = &arg2_str;
62021   argp3 = (Dali::Actor *)jarg3;
62022   if (!argp3) {
62023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62024     return 0;
62025   }
62026   arg3 = *argp3;
62027   {
62028     try {
62029       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
62030     } catch (std::out_of_range& e) {
62031       {
62032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62033       };
62034     } catch (std::exception& e) {
62035       {
62036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62037       };
62038     } catch (Dali::DaliException e) {
62039       {
62040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62041       };
62042     } catch (...) {
62043       {
62044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62045       };
62046     }
62047   }
62048
62049   jresult = new Dali::Animation((const Dali::Animation &)result);
62050
62051   //argout typemap for const std::string&
62052
62053   return jresult;
62054 }
62055
62056
62057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
62058   void * jresult ;
62059   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62060   std::string *arg2 = 0 ;
62061   Dali::Property::Map *arg3 = 0 ;
62062   Dali::Actor arg4 ;
62063   Dali::Actor *argp4 ;
62064   Dali::Animation result;
62065
62066   arg1 = (Dali::Toolkit::Builder *)jarg1;
62067   if (!jarg2) {
62068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62069     return 0;
62070   }
62071   std::string arg2_str(jarg2);
62072   arg2 = &arg2_str;
62073   arg3 = (Dali::Property::Map *)jarg3;
62074   if (!arg3) {
62075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62076     return 0;
62077   }
62078   argp4 = (Dali::Actor *)jarg4;
62079   if (!argp4) {
62080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62081     return 0;
62082   }
62083   arg4 = *argp4;
62084   {
62085     try {
62086       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (Dali::DaliException e) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62102       };
62103     }
62104   }
62105
62106   jresult = new Dali::Animation((const Dali::Animation &)result);
62107
62108   //argout typemap for const std::string&
62109
62110   return jresult;
62111 }
62112
62113
62114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
62115   void * jresult ;
62116   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62117   std::string *arg2 = 0 ;
62118   Dali::BaseHandle result;
62119
62120   arg1 = (Dali::Toolkit::Builder *)jarg1;
62121   if (!jarg2) {
62122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62123     return 0;
62124   }
62125   std::string arg2_str(jarg2);
62126   arg2 = &arg2_str;
62127   {
62128     try {
62129       result = (arg1)->Create((std::string const &)*arg2);
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::BaseHandle((const Dali::BaseHandle &)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_1(void * jarg1, char * jarg2, void * jarg3) {
62158   void * jresult ;
62159   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62160   std::string *arg2 = 0 ;
62161   Dali::Property::Map *arg3 = 0 ;
62162   Dali::BaseHandle result;
62163
62164   arg1 = (Dali::Toolkit::Builder *)jarg1;
62165   if (!jarg2) {
62166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62167     return 0;
62168   }
62169   std::string arg2_str(jarg2);
62170   arg2 = &arg2_str;
62171   arg3 = (Dali::Property::Map *)jarg3;
62172   if (!arg3) {
62173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62174     return 0;
62175   }
62176   {
62177     try {
62178       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
62179     } catch (std::out_of_range& e) {
62180       {
62181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62182       };
62183     } catch (std::exception& e) {
62184       {
62185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62186       };
62187     } catch (Dali::DaliException e) {
62188       {
62189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62190       };
62191     } catch (...) {
62192       {
62193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62194       };
62195     }
62196   }
62197
62198   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
62199
62200   //argout typemap for const std::string&
62201
62202   return jresult;
62203 }
62204
62205
62206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
62207   void * jresult ;
62208   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62209   std::string *arg2 = 0 ;
62210   Dali::BaseHandle result;
62211
62212   arg1 = (Dali::Toolkit::Builder *)jarg1;
62213   if (!jarg2) {
62214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62215     return 0;
62216   }
62217   std::string arg2_str(jarg2);
62218   arg2 = &arg2_str;
62219   {
62220     try {
62221       result = (arg1)->CreateFromJson((std::string const &)*arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
62250   unsigned int jresult ;
62251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62252   std::string *arg2 = 0 ;
62253   Dali::Handle *arg3 = 0 ;
62254   bool result;
62255
62256   arg1 = (Dali::Toolkit::Builder *)jarg1;
62257   if (!jarg2) {
62258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62259     return 0;
62260   }
62261   std::string arg2_str(jarg2);
62262   arg2 = &arg2_str;
62263   arg3 = (Dali::Handle *)jarg3;
62264   if (!arg3) {
62265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62266     return 0;
62267   }
62268   {
62269     try {
62270       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
62271     } catch (std::out_of_range& e) {
62272       {
62273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62274       };
62275     } catch (std::exception& e) {
62276       {
62277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62278       };
62279     } catch (Dali::DaliException e) {
62280       {
62281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62282       };
62283     } catch (...) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62286       };
62287     }
62288   }
62289
62290   jresult = result;
62291
62292   //argout typemap for const std::string&
62293
62294   return jresult;
62295 }
62296
62297
62298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
62299   unsigned int jresult ;
62300   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62301   Dali::Handle *arg2 = 0 ;
62302   std::string *arg3 = 0 ;
62303   bool result;
62304
62305   arg1 = (Dali::Toolkit::Builder *)jarg1;
62306   arg2 = (Dali::Handle *)jarg2;
62307   if (!arg2) {
62308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
62309     return 0;
62310   }
62311   if (!jarg3) {
62312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62313     return 0;
62314   }
62315   std::string arg3_str(jarg3);
62316   arg3 = &arg3_str;
62317   {
62318     try {
62319       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
62320     } catch (std::out_of_range& e) {
62321       {
62322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62323       };
62324     } catch (std::exception& e) {
62325       {
62326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62327       };
62328     } catch (Dali::DaliException e) {
62329       {
62330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62331       };
62332     } catch (...) {
62333       {
62334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62335       };
62336     }
62337   }
62338
62339   jresult = result;
62340
62341   //argout typemap for const std::string&
62342
62343   return jresult;
62344 }
62345
62346
62347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
62348   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62349   Dali::Actor arg2 ;
62350   Dali::Actor *argp2 ;
62351
62352   arg1 = (Dali::Toolkit::Builder *)jarg1;
62353   argp2 = (Dali::Actor *)jarg2;
62354   if (!argp2) {
62355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62356     return ;
62357   }
62358   arg2 = *argp2;
62359   {
62360     try {
62361       (arg1)->AddActors(arg2);
62362     } catch (std::out_of_range& e) {
62363       {
62364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62365       };
62366     } catch (std::exception& e) {
62367       {
62368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62369       };
62370     } catch (Dali::DaliException e) {
62371       {
62372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62373       };
62374     } catch (...) {
62375       {
62376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62377       };
62378     }
62379   }
62380
62381 }
62382
62383
62384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
62385   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62386   std::string *arg2 = 0 ;
62387   Dali::Actor arg3 ;
62388   Dali::Actor *argp3 ;
62389
62390   arg1 = (Dali::Toolkit::Builder *)jarg1;
62391   if (!jarg2) {
62392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62393     return ;
62394   }
62395   std::string arg2_str(jarg2);
62396   arg2 = &arg2_str;
62397   argp3 = (Dali::Actor *)jarg3;
62398   if (!argp3) {
62399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62400     return ;
62401   }
62402   arg3 = *argp3;
62403   {
62404     try {
62405       (arg1)->AddActors((std::string const &)*arg2,arg3);
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (Dali::DaliException e) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62417       };
62418     } catch (...) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62421       };
62422     }
62423   }
62424
62425
62426   //argout typemap for const std::string&
62427
62428 }
62429
62430
62431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
62432   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62433   std::string *arg2 = 0 ;
62434
62435   arg1 = (Dali::Toolkit::Builder *)jarg1;
62436   if (!jarg2) {
62437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62438     return ;
62439   }
62440   std::string arg2_str(jarg2);
62441   arg2 = &arg2_str;
62442   {
62443     try {
62444       (arg1)->CreateRenderTask((std::string const &)*arg2);
62445     } catch (std::out_of_range& e) {
62446       {
62447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62448       };
62449     } catch (std::exception& e) {
62450       {
62451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62452       };
62453     } catch (Dali::DaliException e) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62456       };
62457     } catch (...) {
62458       {
62459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62460       };
62461     }
62462   }
62463
62464
62465   //argout typemap for const std::string&
62466
62467 }
62468
62469
62470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
62471   void * jresult ;
62472   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62473   std::string *arg2 = 0 ;
62474   Dali::FrameBufferImage result;
62475
62476   arg1 = (Dali::Toolkit::Builder *)jarg1;
62477   if (!jarg2) {
62478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62479     return 0;
62480   }
62481   std::string arg2_str(jarg2);
62482   arg2 = &arg2_str;
62483   {
62484     try {
62485       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (Dali::DaliException e) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62497       };
62498     } catch (...) {
62499       {
62500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62501       };
62502     }
62503   }
62504
62505   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62506
62507   //argout typemap for const std::string&
62508
62509   return jresult;
62510 }
62511
62512
62513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62514   void * jresult ;
62515   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62516   std::string *arg2 = 0 ;
62517   Dali::Path 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)->GetPath((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::Path((const Dali::Path &)result);
62549
62550   //argout typemap for const std::string&
62551
62552   return jresult;
62553 }
62554
62555
62556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62557   void * jresult ;
62558   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62559   std::string *arg2 = 0 ;
62560   Dali::PathConstrainer 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)->GetPathConstrainer((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::PathConstrainer((const Dali::PathConstrainer &)result);
62592
62593   //argout typemap for const std::string&
62594
62595   return jresult;
62596 }
62597
62598
62599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62600   void * jresult ;
62601   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62602   std::string *arg2 = 0 ;
62603   Dali::LinearConstrainer 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)->GetLinearConstrainer((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::LinearConstrainer((const Dali::LinearConstrainer &)result);
62635
62636   //argout typemap for const std::string&
62637
62638   return jresult;
62639 }
62640
62641
62642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62643   void * jresult ;
62644   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62645   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62646
62647   arg1 = (Dali::Toolkit::Builder *)jarg1;
62648   {
62649     try {
62650       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62651     } catch (std::out_of_range& e) {
62652       {
62653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62654       };
62655     } catch (std::exception& e) {
62656       {
62657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62658       };
62659     } catch (Dali::DaliException e) {
62660       {
62661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62662       };
62663     } catch (...) {
62664       {
62665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62666       };
62667     }
62668   }
62669
62670   jresult = (void *)result;
62671   return jresult;
62672 }
62673
62674
62675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62676   void * jresult ;
62677   Dali::Toolkit::TransitionData *result = 0 ;
62678
62679   {
62680     try {
62681       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62682     } catch (std::out_of_range& e) {
62683       {
62684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62685       };
62686     } catch (std::exception& e) {
62687       {
62688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62689       };
62690     } catch (Dali::DaliException e) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62697       };
62698     }
62699   }
62700
62701   jresult = (void *)result;
62702   return jresult;
62703 }
62704
62705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62706   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62707
62708   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62709   {
62710     try {
62711       delete arg1;
62712     } catch (std::out_of_range& e) {
62713       {
62714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62715       };
62716     } catch (std::exception& e) {
62717       {
62718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62719       };
62720     } catch (Dali::DaliException e) {
62721       {
62722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62723       };
62724     } catch (...) {
62725       {
62726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62727       };
62728     }
62729   }
62730
62731 }
62732
62733
62734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62735   void * jresult ;
62736   Dali::Property::Map *arg1 = 0 ;
62737   Dali::Toolkit::TransitionData result;
62738
62739   arg1 = (Dali::Property::Map *)jarg1;
62740   if (!arg1) {
62741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62742     return 0;
62743   }
62744   {
62745     try {
62746       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62747     } catch (std::out_of_range& e) {
62748       {
62749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62750       };
62751     } catch (std::exception& e) {
62752       {
62753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62754       };
62755     } catch (Dali::DaliException e) {
62756       {
62757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62758       };
62759     } catch (...) {
62760       {
62761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62762       };
62763     }
62764   }
62765
62766   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62767   return jresult;
62768 }
62769
62770
62771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62772   void * jresult ;
62773   Dali::Property::Array *arg1 = 0 ;
62774   Dali::Toolkit::TransitionData result;
62775
62776   arg1 = (Dali::Property::Array *)jarg1;
62777   if (!arg1) {
62778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62779     return 0;
62780   }
62781   {
62782     try {
62783       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62784     } catch (std::out_of_range& e) {
62785       {
62786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62787       };
62788     } catch (std::exception& e) {
62789       {
62790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62791       };
62792     } catch (Dali::DaliException e) {
62793       {
62794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62795       };
62796     } catch (...) {
62797       {
62798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62799       };
62800     }
62801   }
62802
62803   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62804   return jresult;
62805 }
62806
62807
62808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62809   void * jresult ;
62810   Dali::BaseHandle arg1 ;
62811   Dali::BaseHandle *argp1 ;
62812   Dali::Toolkit::TransitionData result;
62813
62814   argp1 = (Dali::BaseHandle *)jarg1;
62815   if (!argp1) {
62816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62817     return 0;
62818   }
62819   arg1 = *argp1;
62820   {
62821     try {
62822       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62823     } catch (std::out_of_range& e) {
62824       {
62825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62826       };
62827     } catch (std::exception& e) {
62828       {
62829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (Dali::DaliException e) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62838       };
62839     }
62840   }
62841
62842   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62843   return jresult;
62844 }
62845
62846
62847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62848   void * jresult ;
62849   Dali::Toolkit::TransitionData *arg1 = 0 ;
62850   Dali::Toolkit::TransitionData *result = 0 ;
62851
62852   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62853   if (!arg1) {
62854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62855     return 0;
62856   }
62857   {
62858     try {
62859       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62860     } catch (std::out_of_range& e) {
62861       {
62862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62863       };
62864     } catch (std::exception& e) {
62865       {
62866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62867       };
62868     } catch (Dali::DaliException e) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62871       };
62872     } catch (...) {
62873       {
62874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62875       };
62876     }
62877   }
62878
62879   jresult = (void *)result;
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62885   void * jresult ;
62886   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62887   Dali::Toolkit::TransitionData *arg2 = 0 ;
62888   Dali::Toolkit::TransitionData *result = 0 ;
62889
62890   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62891   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62892   if (!arg2) {
62893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62894     return 0;
62895   }
62896   {
62897     try {
62898       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62899     } catch (std::out_of_range& e) {
62900       {
62901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62902       };
62903     } catch (std::exception& e) {
62904       {
62905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62906       };
62907     } catch (Dali::DaliException e) {
62908       {
62909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62910       };
62911     } catch (...) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62914       };
62915     }
62916   }
62917
62918   jresult = (void *)result;
62919   return jresult;
62920 }
62921
62922
62923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62924   unsigned long jresult ;
62925   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62926   size_t result;
62927
62928   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62929   {
62930     try {
62931       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62932     } catch (std::out_of_range& e) {
62933       {
62934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (std::exception& e) {
62937       {
62938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62939       };
62940     } catch (Dali::DaliException e) {
62941       {
62942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62943       };
62944     } catch (...) {
62945       {
62946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62947       };
62948     }
62949   }
62950
62951   jresult = (unsigned long)result;
62952   return jresult;
62953 }
62954
62955
62956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62957   void * jresult ;
62958   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62959   size_t arg2 ;
62960   Dali::Property::Map result;
62961
62962   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62963   arg2 = (size_t)jarg2;
62964   {
62965     try {
62966       result = (arg1)->GetAnimatorAt(arg2);
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (Dali::DaliException e) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62982       };
62983     }
62984   }
62985
62986   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62987   return jresult;
62988 }
62989
62990
62991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_2(void * jarg1) {
62992   void * jresult ;
62993   Dali::Toolkit::Internal::TransitionData *arg1 = (Dali::Toolkit::Internal::TransitionData *) 0 ;
62994   Dali::Toolkit::TransitionData *result = 0 ;
62995
62996   arg1 = (Dali::Toolkit::Internal::TransitionData *)jarg1;
62997   {
62998     try {
62999       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData(arg1);
63000     } catch (std::out_of_range& e) {
63001       {
63002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63003       };
63004     } catch (std::exception& e) {
63005       {
63006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63007       };
63008     } catch (Dali::DaliException e) {
63009       {
63010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63011       };
63012     } catch (...) {
63013       {
63014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63015       };
63016     }
63017   }
63018
63019   jresult = (void *)result;
63020   return jresult;
63021 }
63022
63023
63024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
63025   int jresult ;
63026   int result;
63027
63028   {
63029     try {
63030       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
63031     } catch (std::out_of_range& e) {
63032       {
63033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63034       };
63035     } catch (std::exception& e) {
63036       {
63037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63038       };
63039     } catch (Dali::DaliException e) {
63040       {
63041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63042       };
63043     } catch (...) {
63044       {
63045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63046       };
63047     }
63048   }
63049
63050   jresult = (int)result;
63051   return jresult;
63052 }
63053
63054
63055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
63056   int jresult ;
63057   int result;
63058
63059   {
63060     try {
63061       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
63062     } catch (std::out_of_range& e) {
63063       {
63064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63065       };
63066     } catch (std::exception& e) {
63067       {
63068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63069       };
63070     } catch (Dali::DaliException e) {
63071       {
63072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63073       };
63074     } catch (...) {
63075       {
63076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63077       };
63078     }
63079   }
63080
63081   jresult = (int)result;
63082   return jresult;
63083 }
63084
63085
63086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
63087   int jresult ;
63088   int result;
63089
63090   {
63091     try {
63092       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
63093     } catch (std::out_of_range& e) {
63094       {
63095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63096       };
63097     } catch (std::exception& e) {
63098       {
63099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63100       };
63101     } catch (Dali::DaliException e) {
63102       {
63103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63104       };
63105     } catch (...) {
63106       {
63107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63108       };
63109     }
63110   }
63111
63112   jresult = (int)result;
63113   return jresult;
63114 }
63115
63116
63117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
63118   int jresult ;
63119   int result;
63120
63121   {
63122     try {
63123       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
63124     } catch (std::out_of_range& e) {
63125       {
63126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63127       };
63128     } catch (std::exception& e) {
63129       {
63130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (Dali::DaliException e) {
63133       {
63134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142
63143   jresult = (int)result;
63144   return jresult;
63145 }
63146
63147
63148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
63149   int jresult ;
63150   int result;
63151
63152   {
63153     try {
63154       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63170       };
63171     }
63172   }
63173
63174   jresult = (int)result;
63175   return jresult;
63176 }
63177
63178
63179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
63180   int jresult ;
63181   int result;
63182
63183   {
63184     try {
63185       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (Dali::DaliException e) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63197       };
63198     } catch (...) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63201       };
63202     }
63203   }
63204
63205   jresult = (int)result;
63206   return jresult;
63207 }
63208
63209
63210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
63211   int jresult ;
63212   int result;
63213
63214   {
63215     try {
63216       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63224       };
63225     } catch (Dali::DaliException e) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63232       };
63233     }
63234   }
63235
63236   jresult = (int)result;
63237   return jresult;
63238 }
63239
63240
63241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
63242   int jresult ;
63243   int result;
63244
63245   {
63246     try {
63247       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (Dali::DaliException e) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63259       };
63260     } catch (...) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63263       };
63264     }
63265   }
63266
63267   jresult = (int)result;
63268   return jresult;
63269 }
63270
63271
63272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
63273   int jresult ;
63274   int result;
63275
63276   {
63277     try {
63278       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
63279     } catch (std::out_of_range& e) {
63280       {
63281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63282       };
63283     } catch (std::exception& e) {
63284       {
63285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63286       };
63287     } catch (Dali::DaliException e) {
63288       {
63289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63290       };
63291     } catch (...) {
63292       {
63293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63294       };
63295     }
63296   }
63297
63298   jresult = (int)result;
63299   return jresult;
63300 }
63301
63302
63303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
63304   int jresult ;
63305   int result;
63306
63307   {
63308     try {
63309       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
63310     } catch (std::out_of_range& e) {
63311       {
63312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63313       };
63314     } catch (std::exception& e) {
63315       {
63316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (Dali::DaliException e) {
63319       {
63320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328
63329   jresult = (int)result;
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
63335   int jresult ;
63336   int result;
63337
63338   {
63339     try {
63340       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
63341     } catch (std::out_of_range& e) {
63342       {
63343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63344       };
63345     } catch (std::exception& e) {
63346       {
63347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63348       };
63349     } catch (Dali::DaliException e) {
63350       {
63351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63352       };
63353     } catch (...) {
63354       {
63355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63356       };
63357     }
63358   }
63359
63360   jresult = (int)result;
63361   return jresult;
63362 }
63363
63364
63365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
63366   int jresult ;
63367   int result;
63368
63369   {
63370     try {
63371       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
63372     } catch (std::out_of_range& e) {
63373       {
63374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63375       };
63376     } catch (std::exception& e) {
63377       {
63378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63379       };
63380     } catch (Dali::DaliException e) {
63381       {
63382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63383       };
63384     } catch (...) {
63385       {
63386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63387       };
63388     }
63389   }
63390
63391   jresult = (int)result;
63392   return jresult;
63393 }
63394
63395
63396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
63397   int jresult ;
63398   int result;
63399
63400   {
63401     try {
63402       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
63403     } catch (std::out_of_range& e) {
63404       {
63405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63406       };
63407     } catch (std::exception& e) {
63408       {
63409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63410       };
63411     } catch (Dali::DaliException e) {
63412       {
63413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63414       };
63415     } catch (...) {
63416       {
63417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63418       };
63419     }
63420   }
63421
63422   jresult = (int)result;
63423   return jresult;
63424 }
63425
63426
63427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
63428   int jresult ;
63429   int result;
63430
63431   {
63432     try {
63433       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
63434     } catch (std::out_of_range& e) {
63435       {
63436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (std::exception& e) {
63439       {
63440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (Dali::DaliException e) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63445       };
63446     } catch (...) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63449       };
63450     }
63451   }
63452
63453   jresult = (int)result;
63454   return jresult;
63455 }
63456
63457
63458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
63459   void * jresult ;
63460   Dali::Toolkit::Control result;
63461
63462   {
63463     try {
63464       result = Dali::Toolkit::Internal::Control::New();
63465     } catch (std::out_of_range& e) {
63466       {
63467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63468       };
63469     } catch (std::exception& e) {
63470       {
63471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63472       };
63473     } catch (Dali::DaliException e) {
63474       {
63475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63476       };
63477     } catch (...) {
63478       {
63479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63480       };
63481     }
63482   }
63483
63484   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63485   return jresult;
63486 }
63487
63488
63489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
63490   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63491   std::string *arg2 = 0 ;
63492
63493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63494   if (!jarg2) {
63495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63496     return ;
63497   }
63498   std::string arg2_str(jarg2);
63499   arg2 = &arg2_str;
63500   {
63501     try {
63502       (arg1)->SetStyleName((std::string const &)*arg2);
63503     } catch (std::out_of_range& e) {
63504       {
63505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63506       };
63507     } catch (std::exception& e) {
63508       {
63509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63510       };
63511     } catch (Dali::DaliException e) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63514       };
63515     } catch (...) {
63516       {
63517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63518       };
63519     }
63520   }
63521
63522
63523   //argout typemap for const std::string&
63524
63525 }
63526
63527
63528 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63529   char * jresult ;
63530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63531   std::string *result = 0 ;
63532
63533   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63534   {
63535     try {
63536       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63537     } catch (std::out_of_range& e) {
63538       {
63539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63540       };
63541     } catch (std::exception& e) {
63542       {
63543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63544       };
63545     } catch (Dali::DaliException e) {
63546       {
63547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63548       };
63549     } catch (...) {
63550       {
63551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63552       };
63553     }
63554   }
63555
63556   jresult = SWIG_csharp_string_callback(result->c_str());
63557   return jresult;
63558 }
63559
63560
63561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63562   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63563   Dali::Vector4 *arg2 = 0 ;
63564
63565   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63566   arg2 = (Dali::Vector4 *)jarg2;
63567   if (!arg2) {
63568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63569     return ;
63570   }
63571   {
63572     try {
63573       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63581       };
63582     } catch (Dali::DaliException e) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63589       };
63590     }
63591   }
63592
63593 }
63594
63595
63596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63597   void * jresult ;
63598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63599   Dali::Vector4 result;
63600
63601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63602   {
63603     try {
63604       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (Dali::DaliException e) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63620       };
63621     }
63622   }
63623
63624   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63630   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63631   Dali::Image arg2 ;
63632   Dali::Image *argp2 ;
63633
63634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63635   argp2 = (Dali::Image *)jarg2;
63636   if (!argp2) {
63637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63638     return ;
63639   }
63640   arg2 = *argp2;
63641   {
63642     try {
63643       (arg1)->SetBackgroundImage(arg2);
63644     } catch (std::out_of_range& e) {
63645       {
63646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63647       };
63648     } catch (std::exception& e) {
63649       {
63650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63651       };
63652     } catch (Dali::DaliException e) {
63653       {
63654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63655       };
63656     } catch (...) {
63657       {
63658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63659       };
63660     }
63661   }
63662
63663 }
63664
63665
63666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63667   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63668   Dali::Property::Map *arg2 = 0 ;
63669
63670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63671   arg2 = (Dali::Property::Map *)jarg2;
63672   if (!arg2) {
63673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63674     return ;
63675   }
63676   {
63677     try {
63678       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63679     } catch (std::out_of_range& e) {
63680       {
63681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63682       };
63683     } catch (std::exception& e) {
63684       {
63685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63686       };
63687     } catch (Dali::DaliException e) {
63688       {
63689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63690       };
63691     } catch (...) {
63692       {
63693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63694       };
63695     }
63696   }
63697
63698 }
63699
63700
63701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63703
63704   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63705   {
63706     try {
63707       (arg1)->ClearBackground();
63708     } catch (std::out_of_range& e) {
63709       {
63710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63711       };
63712     } catch (std::exception& e) {
63713       {
63714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63715       };
63716     } catch (Dali::DaliException e) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63719       };
63720     } catch (...) {
63721       {
63722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63723       };
63724     }
63725   }
63726
63727 }
63728
63729
63730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63731   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63732   Dali::Gesture::Type arg2 ;
63733
63734   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63735   arg2 = (Dali::Gesture::Type)jarg2;
63736   {
63737     try {
63738       (arg1)->EnableGestureDetection(arg2);
63739     } catch (std::out_of_range& e) {
63740       {
63741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63742       };
63743     } catch (std::exception& e) {
63744       {
63745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63746       };
63747     } catch (Dali::DaliException e) {
63748       {
63749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63750       };
63751     } catch (...) {
63752       {
63753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63754       };
63755     }
63756   }
63757
63758 }
63759
63760
63761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63762   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63763   Dali::Gesture::Type arg2 ;
63764
63765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63766   arg2 = (Dali::Gesture::Type)jarg2;
63767   {
63768     try {
63769       (arg1)->DisableGestureDetection(arg2);
63770     } catch (std::out_of_range& e) {
63771       {
63772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63773       };
63774     } catch (std::exception& e) {
63775       {
63776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63777       };
63778     } catch (Dali::DaliException e) {
63779       {
63780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63781       };
63782     } catch (...) {
63783       {
63784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63785       };
63786     }
63787   }
63788
63789 }
63790
63791
63792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63793   void * jresult ;
63794   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63795   Dali::PinchGestureDetector result;
63796
63797   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63798   {
63799     try {
63800       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63801     } catch (std::out_of_range& e) {
63802       {
63803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63804       };
63805     } catch (std::exception& e) {
63806       {
63807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63808       };
63809     } catch (Dali::DaliException e) {
63810       {
63811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63812       };
63813     } catch (...) {
63814       {
63815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63816       };
63817     }
63818   }
63819
63820   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63821   return jresult;
63822 }
63823
63824
63825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63826   void * jresult ;
63827   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63828   Dali::PanGestureDetector result;
63829
63830   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63831   {
63832     try {
63833       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63834     } catch (std::out_of_range& e) {
63835       {
63836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63837       };
63838     } catch (std::exception& e) {
63839       {
63840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63841       };
63842     } catch (Dali::DaliException e) {
63843       {
63844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63845       };
63846     } catch (...) {
63847       {
63848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63849       };
63850     }
63851   }
63852
63853   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63854   return jresult;
63855 }
63856
63857
63858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63859   void * jresult ;
63860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63861   Dali::TapGestureDetector result;
63862
63863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63864   {
63865     try {
63866       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63867     } catch (std::out_of_range& e) {
63868       {
63869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63870       };
63871     } catch (std::exception& e) {
63872       {
63873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63874       };
63875     } catch (Dali::DaliException e) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63878       };
63879     } catch (...) {
63880       {
63881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63882       };
63883     }
63884   }
63885
63886   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63887   return jresult;
63888 }
63889
63890
63891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63892   void * jresult ;
63893   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63894   Dali::LongPressGestureDetector result;
63895
63896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63897   {
63898     try {
63899       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63900     } catch (std::out_of_range& e) {
63901       {
63902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63903       };
63904     } catch (std::exception& e) {
63905       {
63906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (Dali::DaliException e) {
63909       {
63910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63911       };
63912     } catch (...) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63915       };
63916     }
63917   }
63918
63919   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63920   return jresult;
63921 }
63922
63923
63924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63926   bool arg2 ;
63927
63928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63929   arg2 = jarg2 ? true : false;
63930   {
63931     try {
63932       (arg1)->SetKeyboardNavigationSupport(arg2);
63933     } catch (std::out_of_range& e) {
63934       {
63935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63936       };
63937     } catch (std::exception& e) {
63938       {
63939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63940       };
63941     } catch (Dali::DaliException e) {
63942       {
63943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63944       };
63945     } catch (...) {
63946       {
63947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63948       };
63949     }
63950   }
63951
63952 }
63953
63954
63955 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63956   unsigned int jresult ;
63957   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63958   bool result;
63959
63960   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63961   {
63962     try {
63963       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63964     } catch (std::out_of_range& e) {
63965       {
63966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63967       };
63968     } catch (std::exception& e) {
63969       {
63970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63971       };
63972     } catch (Dali::DaliException e) {
63973       {
63974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63975       };
63976     } catch (...) {
63977       {
63978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63979       };
63980     }
63981   }
63982
63983   jresult = result;
63984   return jresult;
63985 }
63986
63987
63988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63989   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63990
63991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63992   {
63993     try {
63994       (arg1)->SetKeyInputFocus();
63995     } catch (std::out_of_range& e) {
63996       {
63997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (std::exception& e) {
64000       {
64001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64002       };
64003     } catch (Dali::DaliException e) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64006       };
64007     } catch (...) {
64008       {
64009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64010       };
64011     }
64012   }
64013
64014 }
64015
64016
64017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
64018   unsigned int jresult ;
64019   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64020   bool result;
64021
64022   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64023   {
64024     try {
64025       result = (bool)(arg1)->HasKeyInputFocus();
64026     } catch (std::out_of_range& e) {
64027       {
64028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64029       };
64030     } catch (std::exception& e) {
64031       {
64032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64033       };
64034     } catch (Dali::DaliException e) {
64035       {
64036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64037       };
64038     } catch (...) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64041       };
64042     }
64043   }
64044
64045   jresult = result;
64046   return jresult;
64047 }
64048
64049
64050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
64051   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64052
64053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64054   {
64055     try {
64056       (arg1)->ClearKeyInputFocus();
64057     } catch (std::out_of_range& e) {
64058       {
64059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64060       };
64061     } catch (std::exception& e) {
64062       {
64063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64064       };
64065     } catch (Dali::DaliException e) {
64066       {
64067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64068       };
64069     } catch (...) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64072       };
64073     }
64074   }
64075
64076 }
64077
64078
64079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
64080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64081   bool arg2 ;
64082
64083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64084   arg2 = jarg2 ? true : false;
64085   {
64086     try {
64087       (arg1)->SetAsKeyboardFocusGroup(arg2);
64088     } catch (std::out_of_range& e) {
64089       {
64090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64091       };
64092     } catch (std::exception& e) {
64093       {
64094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64095       };
64096     } catch (Dali::DaliException e) {
64097       {
64098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64099       };
64100     } catch (...) {
64101       {
64102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64103       };
64104     }
64105   }
64106
64107 }
64108
64109
64110 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
64111   unsigned int jresult ;
64112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64113   bool result;
64114
64115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64116   {
64117     try {
64118       result = (bool)(arg1)->IsKeyboardFocusGroup();
64119     } catch (std::out_of_range& e) {
64120       {
64121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64122       };
64123     } catch (std::exception& e) {
64124       {
64125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64126       };
64127     } catch (Dali::DaliException e) {
64128       {
64129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64130       };
64131     } catch (...) {
64132       {
64133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64134       };
64135     }
64136   }
64137
64138   jresult = result;
64139   return jresult;
64140 }
64141
64142
64143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_AccessibilityActivate(void * jarg1) {
64144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64145
64146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64147   {
64148     try {
64149       (arg1)->AccessibilityActivate();
64150     } catch (std::out_of_range& e) {
64151       {
64152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64153       };
64154     } catch (std::exception& e) {
64155       {
64156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64157       };
64158     } catch (Dali::DaliException e) {
64159       {
64160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64161       };
64162     } catch (...) {
64163       {
64164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64165       };
64166     }
64167   }
64168
64169 }
64170
64171
64172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_KeyboardEnter(void * jarg1) {
64173   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64174
64175   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64176   {
64177     try {
64178       (arg1)->KeyboardEnter();
64179     } catch (std::out_of_range& e) {
64180       {
64181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64182       };
64183     } catch (std::exception& e) {
64184       {
64185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64186       };
64187     } catch (Dali::DaliException e) {
64188       {
64189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64190       };
64191     } catch (...) {
64192       {
64193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64194       };
64195     }
64196   }
64197
64198 }
64199
64200
64201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
64202   void * jresult ;
64203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64204   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64205
64206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64207   {
64208     try {
64209       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64210     } catch (std::out_of_range& e) {
64211       {
64212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64213       };
64214     } catch (std::exception& e) {
64215       {
64216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64217       };
64218     } catch (Dali::DaliException e) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64221       };
64222     } catch (...) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64225       };
64226     }
64227   }
64228
64229   jresult = (void *)result;
64230   return jresult;
64231 }
64232
64233
64234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
64235   void * jresult ;
64236   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64237   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64238
64239   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64240   {
64241     try {
64242       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64243     } catch (std::out_of_range& e) {
64244       {
64245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64246       };
64247     } catch (std::exception& e) {
64248       {
64249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64250       };
64251     } catch (Dali::DaliException e) {
64252       {
64253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64254       };
64255     } catch (...) {
64256       {
64257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64258       };
64259     }
64260   }
64261
64262   jresult = (void *)result;
64263   return jresult;
64264 }
64265
64266
64267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
64268   void * jresult ;
64269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64270   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64271
64272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64273   {
64274     try {
64275       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64276     } catch (std::out_of_range& e) {
64277       {
64278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (std::exception& e) {
64281       {
64282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64283       };
64284     } catch (Dali::DaliException e) {
64285       {
64286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64287       };
64288     } catch (...) {
64289       {
64290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64291       };
64292     }
64293   }
64294
64295   jresult = (void *)result;
64296   return jresult;
64297 }
64298
64299
64300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_EmitKeyEventSignal(void * jarg1, void * jarg2) {
64301   unsigned int jresult ;
64302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64303   Dali::KeyEvent *arg2 = 0 ;
64304   bool result;
64305
64306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64307   arg2 = (Dali::KeyEvent *)jarg2;
64308   if (!arg2) {
64309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64310     return 0;
64311   }
64312   {
64313     try {
64314       result = (bool)(arg1)->EmitKeyEventSignal((Dali::KeyEvent const &)*arg2);
64315     } catch (std::out_of_range& e) {
64316       {
64317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64318       };
64319     } catch (std::exception& e) {
64320       {
64321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64322       };
64323     } catch (Dali::DaliException e) {
64324       {
64325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64326       };
64327     } catch (...) {
64328       {
64329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64330       };
64331     }
64332   }
64333
64334   jresult = result;
64335   return jresult;
64336 }
64337
64338
64339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
64340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64341   int arg2 ;
64342   SwigDirector_ViewImpl *darg = 0;
64343
64344   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64345   arg2 = (int)jarg2;
64346   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64347   if(!darg) {
64348     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64349     return;
64350   }
64351   {
64352     try {
64353       if(darg) {
64354         (darg)->OnStageConnection(arg2);
64355       }
64356     } catch (std::out_of_range& e) {
64357       {
64358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64359       };
64360     } catch (std::exception& e) {
64361       {
64362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64363       };
64364     } catch (Dali::DaliException e) {
64365       {
64366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64367       };
64368     } catch (...) {
64369       {
64370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64371       };
64372     }
64373   }
64374
64375 }
64376
64377
64378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
64379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64380   int arg2 ;
64381   SwigDirector_ViewImpl *darg = 0;
64382
64383   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64384   arg2 = (int)jarg2;
64385   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64386   if(!darg) {
64387     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64388     return;
64389   }
64390   {
64391     try {
64392       if(darg) {
64393         (darg)->OnStageConnectionSwigPublic(arg2);
64394       }
64395     } catch (std::out_of_range& e) {
64396       {
64397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64398       };
64399     } catch (std::exception& e) {
64400       {
64401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64402       };
64403     } catch (Dali::DaliException e) {
64404       {
64405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64406       };
64407     } catch (...) {
64408       {
64409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64410       };
64411     }
64412   }
64413
64414 }
64415
64416
64417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
64418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64419   SwigDirector_ViewImpl *darg = 0;
64420
64421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64422   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64423   if(!darg) {
64424     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64425     return;
64426   }
64427   {
64428     try {
64429       if(darg) {
64430         (darg)->OnStageDisconnection();
64431       }
64432     } catch (std::out_of_range& e) {
64433       {
64434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64435       };
64436     } catch (std::exception& e) {
64437       {
64438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64439       };
64440     } catch (Dali::DaliException e) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64443       };
64444     } catch (...) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64447       };
64448     }
64449   }
64450
64451 }
64452
64453
64454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
64455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64456   SwigDirector_ViewImpl *darg = 0;
64457
64458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64459   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64460   if(!darg) {
64461     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64462     return;
64463   }
64464   {
64465     try {
64466       if(darg) {
64467         (darg)->OnStageDisconnectionSwigPublic();
64468       }
64469     } catch (std::out_of_range& e) {
64470       {
64471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64472       };
64473     } catch (std::exception& e) {
64474       {
64475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64476       };
64477     } catch (Dali::DaliException e) {
64478       {
64479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64484       };
64485     }
64486   }
64487
64488 }
64489
64490
64491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
64492   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64493   Dali::Actor *arg2 = 0 ;
64494   SwigDirector_ViewImpl *darg = 0;
64495
64496   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64497   arg2 = (Dali::Actor *)jarg2;
64498   if (!arg2) {
64499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64500     return ;
64501   }
64502   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64503   if(!darg) {
64504     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64505     return;
64506   }
64507   {
64508     try {
64509       if(darg) {
64510         (darg)->OnChildAdd(*arg2);
64511       }
64512     } catch (std::out_of_range& e) {
64513       {
64514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64515       };
64516     } catch (std::exception& e) {
64517       {
64518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64519       };
64520     } catch (Dali::DaliException e) {
64521       {
64522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64523       };
64524     } catch (...) {
64525       {
64526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64527       };
64528     }
64529   }
64530
64531 }
64532
64533
64534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64536   Dali::Actor *arg2 = 0 ;
64537   SwigDirector_ViewImpl *darg = 0;
64538
64539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64540   arg2 = (Dali::Actor *)jarg2;
64541   if (!arg2) {
64542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64543     return ;
64544   }
64545   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64546   if(!darg) {
64547     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64548     return;
64549   }
64550   {
64551     try {
64552       if(darg) {
64553           (darg)->OnChildAddSwigPublic(*arg2);
64554       }
64555     } catch (std::out_of_range& e) {
64556       {
64557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64558       };
64559     } catch (std::exception& e) {
64560       {
64561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64562       };
64563     } catch (Dali::DaliException e) {
64564       {
64565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64566       };
64567     } catch (...) {
64568       {
64569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64570       };
64571     }
64572   }
64573
64574 }
64575
64576
64577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
64578   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64579   Dali::Actor *arg2 = 0 ;
64580   SwigDirector_ViewImpl *darg = 0;
64581
64582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64583   arg2 = (Dali::Actor *)jarg2;
64584   if (!arg2) {
64585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64586     return ;
64587   }
64588   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64589   if(!darg) {
64590     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64591     return;
64592   }
64593   {
64594     try {
64595       if(darg) {
64596         (darg)->OnChildRemove(*arg2);
64597       }
64598     } catch (std::out_of_range& e) {
64599       {
64600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64601       };
64602     } catch (std::exception& e) {
64603       {
64604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64605       };
64606     } catch (Dali::DaliException e) {
64607       {
64608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64609       };
64610     } catch (...) {
64611       {
64612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64613       };
64614     }
64615   }
64616
64617 }
64618
64619
64620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64621   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64622   Dali::Actor *arg2 = 0 ;
64623   SwigDirector_ViewImpl *darg = 0;
64624
64625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64626   arg2 = (Dali::Actor *)jarg2;
64627   if (!arg2) {
64628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64629     return ;
64630   }
64631   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64632   if(!darg) {
64633     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64634     return;
64635   }
64636   {
64637     try {
64638       if(darg) {
64639         (darg)->OnChildRemoveSwigPublic(*arg2);
64640       }
64641     } catch (std::out_of_range& e) {
64642       {
64643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64644       };
64645     } catch (std::exception& e) {
64646       {
64647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64648       };
64649     } catch (Dali::DaliException e) {
64650       {
64651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64652       };
64653     } catch (...) {
64654       {
64655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64656       };
64657     }
64658   }
64659
64660 }
64661
64662
64663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64665   Dali::Property::Index arg2 ;
64666   Dali::Property::Value arg3 ;
64667   Dali::Property::Value *argp3 ;
64668   SwigDirector_ViewImpl *darg = 0;
64669
64670   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64671   arg2 = (Dali::Property::Index)jarg2;
64672   argp3 = (Dali::Property::Value *)jarg3;
64673   if (!argp3) {
64674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64675     return ;
64676   }
64677   arg3 = *argp3;
64678   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64679   if (!darg) {
64680     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64681     return;
64682   }
64683   {
64684     try {
64685       (darg)->OnPropertySet(arg2,arg3);
64686     } catch (std::out_of_range& e) {
64687       {
64688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64689       };
64690     } catch (std::exception& e) {
64691       {
64692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64693       };
64694     } catch (Dali::DaliException e) {
64695       {
64696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64697       };
64698     } catch (...) {
64699       {
64700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64701       };
64702     }
64703   }
64704
64705 }
64706
64707
64708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64709   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64710   Dali::Property::Index arg2 ;
64711   Dali::Property::Value arg3 ;
64712   Dali::Property::Value *argp3 ;
64713   SwigDirector_ViewImpl *darg = 0;
64714
64715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64716   arg2 = (Dali::Property::Index)jarg2;
64717   argp3 = (Dali::Property::Value *)jarg3;
64718   if (!argp3) {
64719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64720     return ;
64721   }
64722   arg3 = *argp3;
64723   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64724   if (!darg) {
64725     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64726     return;
64727   }
64728   {
64729     try {
64730       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64731     } catch (std::out_of_range& e) {
64732       {
64733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64734       };
64735     } catch (std::exception& e) {
64736       {
64737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64738       };
64739     } catch (Dali::DaliException e) {
64740       {
64741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64742       };
64743     } catch (...) {
64744       {
64745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64746       };
64747     }
64748   }
64749
64750 }
64751
64752
64753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64755   Dali::Vector3 *arg2 = 0 ;
64756   SwigDirector_ViewImpl *darg = 0;
64757
64758   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64759   arg2 = (Dali::Vector3 *)jarg2;
64760   if (!arg2) {
64761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64762     return ;
64763   }
64764   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64765   if (!darg) {
64766     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64767     return;
64768   }
64769   {
64770     try {
64771       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64772     } catch (std::out_of_range& e) {
64773       {
64774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64775       };
64776     } catch (std::exception& e) {
64777       {
64778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64779       };
64780     } catch (Dali::DaliException e) {
64781       {
64782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64783       };
64784     } catch (...) {
64785       {
64786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64787       };
64788     }
64789   }
64790
64791 }
64792
64793
64794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64795   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64796   Dali::Vector3 *arg2 = 0 ;
64797   SwigDirector_ViewImpl *darg = 0;
64798
64799   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64800   arg2 = (Dali::Vector3 *)jarg2;
64801   if (!arg2) {
64802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64803     return ;
64804   }
64805   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64806   if (!darg) {
64807     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64808     return;
64809   }
64810   {
64811     try {
64812       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64820       };
64821     } catch (Dali::DaliException e) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64824       };
64825     } catch (...) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64828       };
64829     }
64830   }
64831
64832 }
64833
64834
64835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64837   Dali::Animation *arg2 = 0 ;
64838   Dali::Vector3 *arg3 = 0 ;
64839   SwigDirector_ViewImpl *darg = 0;
64840
64841   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64842   arg2 = (Dali::Animation *)jarg2;
64843   if (!arg2) {
64844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64845     return ;
64846   }
64847   arg3 = (Dali::Vector3 *)jarg3;
64848   if (!arg3) {
64849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64850     return ;
64851   }
64852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64853   if (!darg) {
64854     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64855     return;
64856   }
64857   {
64858     try {
64859       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64860     } catch (std::out_of_range& e) {
64861       {
64862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64863       };
64864     } catch (std::exception& e) {
64865       {
64866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64867       };
64868     } catch (Dali::DaliException e) {
64869       {
64870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64871       };
64872     } catch (...) {
64873       {
64874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64875       };
64876     }
64877   }
64878
64879 }
64880
64881
64882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64884   Dali::Animation *arg2 = 0 ;
64885   Dali::Vector3 *arg3 = 0 ;
64886   SwigDirector_ViewImpl *darg = 0;
64887
64888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64889   arg2 = (Dali::Animation *)jarg2;
64890   if (!arg2) {
64891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64892     return ;
64893   }
64894   arg3 = (Dali::Vector3 *)jarg3;
64895   if (!arg3) {
64896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64897     return ;
64898   }
64899   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64900   if (!darg) {
64901     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64902     return;
64903   }
64904   {
64905     try {
64906       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64907     } catch (std::out_of_range& e) {
64908       {
64909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64910       };
64911     } catch (std::exception& e) {
64912       {
64913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64914       };
64915     } catch (Dali::DaliException e) {
64916       {
64917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64918       };
64919     } catch (...) {
64920       {
64921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64922       };
64923     }
64924   }
64925
64926 }
64927
64928
64929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64930   unsigned int jresult ;
64931   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64932   Dali::TouchEvent *arg2 = 0 ;
64933   SwigDirector_ViewImpl *darg = 0;
64934   bool result;
64935
64936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64937   arg2 = (Dali::TouchEvent *)jarg2;
64938   if (!arg2) {
64939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64940     return 0;
64941   }
64942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64943   if (!darg) {
64944     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64945     return 0;
64946   }
64947   {
64948     try {
64949       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64950     } catch (std::out_of_range& e) {
64951       {
64952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64953       };
64954     } catch (std::exception& e) {
64955       {
64956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64957       };
64958     } catch (Dali::DaliException e) {
64959       {
64960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64961       };
64962     } catch (...) {
64963       {
64964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64965       };
64966     }
64967   }
64968
64969   jresult = result;
64970   return jresult;
64971 }
64972
64973
64974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64975   unsigned int jresult ;
64976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64977   Dali::TouchEvent *arg2 = 0 ;
64978   SwigDirector_ViewImpl *darg = 0;
64979   bool result;
64980
64981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64982   arg2 = (Dali::TouchEvent *)jarg2;
64983   if (!arg2) {
64984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64985     return 0;
64986   }
64987   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64988   if (!darg) {
64989     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64990     return 0;
64991   }
64992   {
64993     try {
64994       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64995     } catch (std::out_of_range& e) {
64996       {
64997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64998       };
64999     } catch (std::exception& e) {
65000       {
65001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65002       };
65003     } catch (Dali::DaliException e) {
65004       {
65005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65006       };
65007     } catch (...) {
65008       {
65009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65010       };
65011     }
65012   }
65013
65014   jresult = result;
65015   return jresult;
65016 }
65017
65018
65019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
65020   unsigned int jresult ;
65021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65022   Dali::HoverEvent *arg2 = 0 ;
65023   SwigDirector_ViewImpl *darg = 0;
65024   bool result;
65025
65026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65027   arg2 = (Dali::HoverEvent *)jarg2;
65028   if (!arg2) {
65029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65030     return 0;
65031   }
65032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65033   if (!darg) {
65034     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65035     return 0;
65036   }
65037   {
65038     try {
65039       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
65040     } catch (std::out_of_range& e) {
65041       {
65042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65043       };
65044     } catch (std::exception& e) {
65045       {
65046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65047       };
65048     } catch (Dali::DaliException e) {
65049       {
65050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65055       };
65056     }
65057   }
65058
65059   jresult = result;
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65065   unsigned int jresult ;
65066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65067   Dali::HoverEvent *arg2 = 0 ;
65068   SwigDirector_ViewImpl *darg = 0;
65069   bool result;
65070
65071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65072   arg2 = (Dali::HoverEvent *)jarg2;
65073   if (!arg2) {
65074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
65075     return 0;
65076   }
65077   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65078   if (!darg) {
65079     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65080     return 0;
65081   }
65082   {
65083     try {
65084       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
65085     } catch (std::out_of_range& e) {
65086       {
65087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65088       };
65089     } catch (std::exception& e) {
65090       {
65091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65092       };
65093     } catch (Dali::DaliException e) {
65094       {
65095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65096       };
65097     } catch (...) {
65098       {
65099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65100       };
65101     }
65102   }
65103
65104   jresult = result;
65105   return jresult;
65106 }
65107
65108
65109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
65110   unsigned int jresult ;
65111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65112   Dali::KeyEvent *arg2 = 0 ;
65113   SwigDirector_ViewImpl *darg = 0;
65114   bool result;
65115
65116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65117   arg2 = (Dali::KeyEvent *)jarg2;
65118   if (!arg2) {
65119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65120     return 0;
65121   }
65122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65123   if (!darg) {
65124     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65125     return 0;
65126   }
65127   {
65128     try {
65129       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
65130     } catch (std::out_of_range& e) {
65131       {
65132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65133       };
65134     } catch (std::exception& e) {
65135       {
65136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65137       };
65138     } catch (Dali::DaliException e) {
65139       {
65140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65141       };
65142     } catch (...) {
65143       {
65144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65145       };
65146     }
65147   }
65148
65149   jresult = result;
65150   return jresult;
65151 }
65152
65153
65154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65155   unsigned int jresult ;
65156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65157   Dali::KeyEvent *arg2 = 0 ;
65158   SwigDirector_ViewImpl *darg = 0;
65159   bool result;
65160
65161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65162   arg2 = (Dali::KeyEvent *)jarg2;
65163   if (!arg2) {
65164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
65165     return 0;
65166   }
65167   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65168   if (!darg) {
65169     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65170     return 0;
65171   }
65172   {
65173     try {
65174       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
65175     } catch (std::out_of_range& e) {
65176       {
65177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (std::exception& e) {
65180       {
65181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65182       };
65183     } catch (Dali::DaliException e) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65186       };
65187     } catch (...) {
65188       {
65189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65190       };
65191     }
65192   }
65193
65194   jresult = result;
65195   return jresult;
65196 }
65197
65198
65199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
65200   unsigned int jresult ;
65201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65202   Dali::WheelEvent *arg2 = 0 ;
65203   SwigDirector_ViewImpl *darg = 0;
65204   bool result;
65205
65206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65207   arg2 = (Dali::WheelEvent *)jarg2;
65208   if (!arg2) {
65209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65210     return 0;
65211   }
65212   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65213   if (!darg) {
65214     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65215     return 0;
65216   }
65217   {
65218     try {
65219       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
65220     } catch (std::out_of_range& e) {
65221       {
65222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65223       };
65224     } catch (std::exception& e) {
65225       {
65226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65227       };
65228     } catch (Dali::DaliException e) {
65229       {
65230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65231       };
65232     } catch (...) {
65233       {
65234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65235       };
65236     }
65237   }
65238
65239   jresult = result;
65240   return jresult;
65241 }
65242
65243
65244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65245   unsigned int jresult ;
65246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65247   Dali::WheelEvent *arg2 = 0 ;
65248   SwigDirector_ViewImpl *darg = 0;
65249   bool result;
65250
65251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65252   arg2 = (Dali::WheelEvent *)jarg2;
65253   if (!arg2) {
65254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
65255     return 0;
65256   }
65257   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65258   if (!darg) {
65259     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65260     return 0;
65261   }
65262   {
65263     try {
65264       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
65265     } catch (std::out_of_range& e) {
65266       {
65267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65268       };
65269     } catch (std::exception& e) {
65270       {
65271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65272       };
65273     } catch (Dali::DaliException e) {
65274       {
65275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65276       };
65277     } catch (...) {
65278       {
65279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65280       };
65281     }
65282   }
65283
65284   jresult = result;
65285   return jresult;
65286 }
65287
65288
65289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
65290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65291   Dali::Vector2 *arg2 = 0 ;
65292   Dali::RelayoutContainer *arg3 = 0 ;
65293   SwigDirector_ViewImpl *darg = 0;
65294
65295   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65296   arg2 = (Dali::Vector2 *)jarg2;
65297   if (!arg2) {
65298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65299     return ;
65300   }
65301   arg3 = (Dali::RelayoutContainer *)jarg3;
65302   if (!arg3) {
65303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65304     return ;
65305   }
65306   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65307   if (!darg) {
65308     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65309     return;
65310   }
65311   {
65312     try {
65313       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
65314     } catch (std::out_of_range& e) {
65315       {
65316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65317       };
65318     } catch (std::exception& e) {
65319       {
65320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65321       };
65322     } catch (Dali::DaliException e) {
65323       {
65324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65325       };
65326     } catch (...) {
65327       {
65328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65329       };
65330     }
65331   }
65332
65333 }
65334
65335
65336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65338   Dali::Vector2 *arg2 = 0 ;
65339   Dali::RelayoutContainer *arg3 = 0 ;
65340   SwigDirector_ViewImpl *darg = 0;
65341
65342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65343   arg2 = (Dali::Vector2 *)jarg2;
65344   if (!arg2) {
65345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
65346     return ;
65347   }
65348   arg3 = (Dali::RelayoutContainer *)jarg3;
65349   if (!arg3) {
65350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
65351     return ;
65352   }
65353   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65354   if (!darg) {
65355     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65356     return;
65357   }
65358   {
65359     try {
65360       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
65361     } catch (std::out_of_range& e) {
65362       {
65363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65364       };
65365     } catch (std::exception& e) {
65366       {
65367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65368       };
65369     } catch (Dali::DaliException e) {
65370       {
65371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65376       };
65377     }
65378   }
65379
65380 }
65381
65382
65383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
65384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65385   Dali::ResizePolicy::Type arg2 ;
65386   Dali::Dimension::Type arg3 ;
65387   SwigDirector_ViewImpl *darg = 0;
65388
65389   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65390   arg2 = (Dali::ResizePolicy::Type)jarg2;
65391   arg3 = (Dali::Dimension::Type)jarg3;
65392   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65393   if (!darg) {
65394     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65395     return;
65396   }
65397   {
65398     try {
65399       (darg)->OnSetResizePolicy(arg2,arg3);
65400     } catch (std::out_of_range& e) {
65401       {
65402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65403       };
65404     } catch (std::exception& e) {
65405       {
65406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65407       };
65408     } catch (Dali::DaliException e) {
65409       {
65410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65411       };
65412     } catch (...) {
65413       {
65414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65415       };
65416     }
65417   }
65418
65419 }
65420
65421
65422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
65423   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65424   Dali::ResizePolicy::Type arg2 ;
65425   Dali::Dimension::Type arg3 ;
65426   SwigDirector_ViewImpl *darg = 0;
65427
65428   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65429   arg2 = (Dali::ResizePolicy::Type)jarg2;
65430   arg3 = (Dali::Dimension::Type)jarg3;
65431   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65432   if (!darg) {
65433     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65434     return;
65435   }
65436   {
65437     try {
65438       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
65439     } catch (std::out_of_range& e) {
65440       {
65441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65442       };
65443     } catch (std::exception& e) {
65444       {
65445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65446       };
65447     } catch (Dali::DaliException e) {
65448       {
65449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65450       };
65451     } catch (...) {
65452       {
65453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65454       };
65455     }
65456   }
65457
65458 }
65459
65460
65461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
65462   void * jresult ;
65463   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65464   SwigDirector_ViewImpl *darg = 0;
65465   Dali::Vector3 result;
65466
65467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65469   if (!darg) {
65470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65471     return 0;
65472   }
65473   {
65474     try {
65475       result = (darg)->GetNaturalSize();
65476     } catch (std::out_of_range& e) {
65477       {
65478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65479       };
65480     } catch (std::exception& e) {
65481       {
65482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65483       };
65484     } catch (Dali::DaliException e) {
65485       {
65486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65487       };
65488     } catch (...) {
65489       {
65490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65491       };
65492     }
65493   }
65494
65495   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65496   return jresult;
65497 }
65498
65499
65500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
65501   void * jresult ;
65502   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65503   SwigDirector_ViewImpl *darg = 0;
65504   Dali::Vector3 result;
65505
65506   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65507   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65508   if (!darg) {
65509     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65510     return 0;
65511   }
65512   {
65513     try {
65514       result = (darg)->GetNaturalSizeSwigPublic();
65515     } catch (std::out_of_range& e) {
65516       {
65517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65518       };
65519     } catch (std::exception& e) {
65520       {
65521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65522       };
65523     } catch (Dali::DaliException e) {
65524       {
65525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65526       };
65527     } catch (...) {
65528       {
65529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65530       };
65531     }
65532   }
65533
65534   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
65535   return jresult;
65536 }
65537
65538
65539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
65540   float jresult ;
65541   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65542   Dali::Actor *arg2 = 0 ;
65543   Dali::Dimension::Type arg3 ;
65544   SwigDirector_ViewImpl *darg = 0;
65545   float result;
65546
65547   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65548   arg2 = (Dali::Actor *)jarg2;
65549   if (!arg2) {
65550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65551     return 0;
65552   }
65553   arg3 = (Dali::Dimension::Type)jarg3;
65554   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65555   if (!darg) {
65556     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65557     return 0;
65558   }
65559   {
65560     try {
65561       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
65562     } catch (std::out_of_range& e) {
65563       {
65564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65565       };
65566     } catch (std::exception& e) {
65567       {
65568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65569       };
65570     } catch (Dali::DaliException e) {
65571       {
65572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65573       };
65574     } catch (...) {
65575       {
65576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65577       };
65578     }
65579   }
65580
65581   jresult = result;
65582   return jresult;
65583 }
65584
65585
65586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65587   float jresult ;
65588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65589   Dali::Actor *arg2 = 0 ;
65590   Dali::Dimension::Type arg3 ;
65591   SwigDirector_ViewImpl *darg = 0;
65592   float result;
65593
65594   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65595   arg2 = (Dali::Actor *)jarg2;
65596   if (!arg2) {
65597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
65598     return 0;
65599   }
65600   arg3 = (Dali::Dimension::Type)jarg3;
65601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65602   if (!darg) {
65603     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65604     return 0;
65605   }
65606   {
65607     try {
65608       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
65609     } catch (std::out_of_range& e) {
65610       {
65611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65612       };
65613     } catch (std::exception& e) {
65614       {
65615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65616       };
65617     } catch (Dali::DaliException e) {
65618       {
65619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65620       };
65621     } catch (...) {
65622       {
65623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65624       };
65625     }
65626   }
65627
65628   jresult = result;
65629   return jresult;
65630 }
65631
65632
65633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65634   float jresult ;
65635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65636   float arg2 ;
65637   SwigDirector_ViewImpl *darg = 0;
65638   float result;
65639
65640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65641   arg2 = (float)jarg2;
65642   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65643   if (!darg) {
65644     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65645     return 0;
65646   }
65647   {
65648     try {
65649       result = (float)(darg)->GetHeightForWidth(arg2);
65650     } catch (std::out_of_range& e) {
65651       {
65652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65653       };
65654     } catch (std::exception& e) {
65655       {
65656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65657       };
65658     } catch (Dali::DaliException e) {
65659       {
65660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65661       };
65662     } catch (...) {
65663       {
65664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65665       };
65666     }
65667   }
65668
65669   jresult = result;
65670   return jresult;
65671 }
65672
65673
65674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65675   float jresult ;
65676   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65677   float arg2 ;
65678   SwigDirector_ViewImpl *darg = 0;
65679   float result;
65680
65681   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65682   arg2 = (float)jarg2;
65683   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65684   if (!darg) {
65685     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65686     return 0;
65687   }
65688   {
65689     try {
65690       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65691     } catch (std::out_of_range& e) {
65692       {
65693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65694       };
65695     } catch (std::exception& e) {
65696       {
65697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65698       };
65699     } catch (Dali::DaliException e) {
65700       {
65701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65702       };
65703     } catch (...) {
65704       {
65705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65706       };
65707     }
65708   }
65709
65710   jresult = result;
65711   return jresult;
65712 }
65713
65714
65715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65716   float jresult ;
65717   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65718   float arg2 ;
65719   SwigDirector_ViewImpl *darg = 0;
65720   float result;
65721
65722   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65723   arg2 = (float)jarg2;
65724   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65725   if (!darg) {
65726     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65727     return 0;
65728   }
65729   {
65730     try {
65731       result = (float)(darg)->GetWidthForHeight(arg2);
65732     } catch (std::out_of_range& e) {
65733       {
65734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65735       };
65736     } catch (std::exception& e) {
65737       {
65738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65739       };
65740     } catch (Dali::DaliException e) {
65741       {
65742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65743       };
65744     } catch (...) {
65745       {
65746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65747       };
65748     }
65749   }
65750
65751   jresult = result;
65752   return jresult;
65753 }
65754
65755
65756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65757   float jresult ;
65758   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65759   float arg2 ;
65760   SwigDirector_ViewImpl *darg = 0;
65761   float result;
65762
65763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65764   arg2 = (float)jarg2;
65765   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65766   if (!darg) {
65767     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65768     return 0;
65769   }
65770   {
65771     try {
65772       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (Dali::DaliException e) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65784       };
65785     } catch (...) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65788       };
65789     }
65790   }
65791
65792   jresult = result;
65793   return jresult;
65794 }
65795
65796
65797 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65798   unsigned int jresult ;
65799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65800   Dali::Dimension::Type arg2 ;
65801   SwigDirector_ViewImpl *darg = 0;
65802   bool result;
65803
65804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65805   arg2 = (Dali::Dimension::Type)jarg2;
65806   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65807   if (!darg) {
65808     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65809     return 0;
65810   }
65811   {
65812     try {
65813       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65814     } catch (std::out_of_range& e) {
65815       {
65816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65817       };
65818     } catch (std::exception& e) {
65819       {
65820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65821       };
65822     } catch (Dali::DaliException e) {
65823       {
65824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65825       };
65826     } catch (...) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65829       };
65830     }
65831   }
65832
65833   jresult = result;
65834   return jresult;
65835 }
65836
65837
65838 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65839   unsigned int jresult ;
65840   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65841   Dali::Dimension::Type arg2 ;
65842   SwigDirector_ViewImpl *darg = 0;
65843   bool result;
65844
65845   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65846   arg2 = (Dali::Dimension::Type)jarg2;
65847   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65848   if (!darg) {
65849     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65850     return 0;
65851   }
65852   {
65853     try {
65854       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65855     } catch (std::out_of_range& e) {
65856       {
65857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (std::exception& e) {
65860       {
65861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (Dali::DaliException e) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65866       };
65867     } catch (...) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65870       };
65871     }
65872   }
65873
65874   jresult = result;
65875   return jresult;
65876 }
65877
65878
65879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65880   unsigned int jresult ;
65881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65882   SwigDirector_ViewImpl *darg = 0;
65883   bool result;
65884
65885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65886   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65887   if (!darg) {
65888     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65889     return 0;
65890   }
65891   {
65892     try {
65893       result = (bool)(darg)->RelayoutDependentOnChildren();
65894     } catch (std::out_of_range& e) {
65895       {
65896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65897       };
65898     } catch (std::exception& e) {
65899       {
65900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65901       };
65902     } catch (Dali::DaliException e) {
65903       {
65904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65905       };
65906     } catch (...) {
65907       {
65908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65909       };
65910     }
65911   }
65912
65913   jresult = result;
65914   return jresult;
65915 }
65916
65917
65918 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65919   unsigned int jresult ;
65920   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65921   SwigDirector_ViewImpl *darg = 0;
65922   bool result;
65923
65924   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65925   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65926   if (!darg) {
65927     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65928     return 0;
65929   }
65930   {
65931     try {
65932       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65933     } catch (std::out_of_range& e) {
65934       {
65935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65936       };
65937     } catch (std::exception& e) {
65938       {
65939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65940       };
65941     } catch (Dali::DaliException e) {
65942       {
65943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65944       };
65945     } catch (...) {
65946       {
65947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65948       };
65949     }
65950   }
65951
65952   jresult = result;
65953   return jresult;
65954 }
65955
65956
65957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65958   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65959   Dali::Dimension::Type arg2 ;
65960   SwigDirector_ViewImpl *darg = 0;
65961
65962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65963   arg2 = (Dali::Dimension::Type)jarg2;
65964   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65965   if (!darg) {
65966     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65967     return;
65968   }
65969   {
65970     try {
65971       (darg)->OnCalculateRelayoutSize(arg2);
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65979       };
65980     } catch (Dali::DaliException e) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65983       };
65984     } catch (...) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65987       };
65988     }
65989   }
65990
65991 }
65992
65993
65994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65996   Dali::Dimension::Type arg2 ;
65997   SwigDirector_ViewImpl *darg = 0;
65998
65999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66000   arg2 = (Dali::Dimension::Type)jarg2;
66001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66002   if (!darg) {
66003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66004     return;
66005   }
66006   {
66007     try {
66008       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
66009     } catch (std::out_of_range& e) {
66010       {
66011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66012       };
66013     } catch (std::exception& e) {
66014       {
66015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66016       };
66017     } catch (Dali::DaliException e) {
66018       {
66019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66020       };
66021     } catch (...) {
66022       {
66023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66024       };
66025     }
66026   }
66027
66028 }
66029
66030
66031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
66032   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66033   float arg2 ;
66034   Dali::Dimension::Type arg3 ;
66035   SwigDirector_ViewImpl *darg = 0;
66036
66037   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66038   arg2 = (float)jarg2;
66039   arg3 = (Dali::Dimension::Type)jarg3;
66040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66041   if (!darg) {
66042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66043     return;
66044   }
66045   {
66046     try {
66047       (darg)->OnLayoutNegotiated(arg2,arg3);
66048     } catch (std::out_of_range& e) {
66049       {
66050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66051       };
66052     } catch (std::exception& e) {
66053       {
66054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66055       };
66056     } catch (Dali::DaliException e) {
66057       {
66058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66059       };
66060     } catch (...) {
66061       {
66062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66063       };
66064     }
66065   }
66066
66067 }
66068
66069
66070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
66071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66072   float arg2 ;
66073   Dali::Dimension::Type arg3 ;
66074   SwigDirector_ViewImpl *darg = 0;
66075
66076   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66077   arg2 = (float)jarg2;
66078   arg3 = (Dali::Dimension::Type)jarg3;
66079   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
66080   if (!darg) {
66081     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
66082     return;
66083   }
66084   {
66085     try {
66086       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
66087     } catch (std::out_of_range& e) {
66088       {
66089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66090       };
66091     } catch (std::exception& e) {
66092       {
66093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66094       };
66095     } catch (Dali::DaliException e) {
66096       {
66097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66098       };
66099     } catch (...) {
66100       {
66101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66102       };
66103     }
66104   }
66105
66106 }
66107
66108
66109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
66110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66111
66112   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66113   {
66114     try {
66115       (arg1)->OnInitialize();
66116     } catch (std::out_of_range& e) {
66117       {
66118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66119       };
66120     } catch (std::exception& e) {
66121       {
66122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66123       };
66124     } catch (Dali::DaliException e) {
66125       {
66126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66127       };
66128     } catch (...) {
66129       {
66130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66131       };
66132     }
66133   }
66134
66135 }
66136
66137
66138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
66139   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66140
66141   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66142   {
66143     try {
66144       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
66145     } catch (std::out_of_range& e) {
66146       {
66147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66148       };
66149     } catch (std::exception& e) {
66150       {
66151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66152       };
66153     } catch (Dali::DaliException e) {
66154       {
66155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66156       };
66157     } catch (...) {
66158       {
66159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66160       };
66161     }
66162   }
66163
66164 }
66165
66166
66167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
66168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66169   Dali::Actor *arg2 = 0 ;
66170
66171   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66172   arg2 = (Dali::Actor *)jarg2;
66173   if (!arg2) {
66174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66175     return ;
66176   }
66177   {
66178     try {
66179       (arg1)->OnControlChildAdd(*arg2);
66180     } catch (std::out_of_range& e) {
66181       {
66182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66183       };
66184     } catch (std::exception& e) {
66185       {
66186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66187       };
66188     } catch (Dali::DaliException e) {
66189       {
66190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66191       };
66192     } catch (...) {
66193       {
66194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66195       };
66196     }
66197   }
66198
66199 }
66200
66201
66202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66203   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66204   Dali::Actor *arg2 = 0 ;
66205
66206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66207   arg2 = (Dali::Actor *)jarg2;
66208   if (!arg2) {
66209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66210     return ;
66211   }
66212   {
66213     try {
66214       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
66215     } catch (std::out_of_range& e) {
66216       {
66217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66218       };
66219     } catch (std::exception& e) {
66220       {
66221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66222       };
66223     } catch (Dali::DaliException e) {
66224       {
66225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66226       };
66227     } catch (...) {
66228       {
66229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66230       };
66231     }
66232   }
66233
66234 }
66235
66236
66237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
66238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66239   Dali::Actor *arg2 = 0 ;
66240
66241   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66242   arg2 = (Dali::Actor *)jarg2;
66243   if (!arg2) {
66244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66245     return ;
66246   }
66247   {
66248     try {
66249       (arg1)->OnControlChildRemove(*arg2);
66250     } catch (std::out_of_range& e) {
66251       {
66252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66253       };
66254     } catch (std::exception& e) {
66255       {
66256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66257       };
66258     } catch (Dali::DaliException e) {
66259       {
66260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66261       };
66262     } catch (...) {
66263       {
66264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66265       };
66266     }
66267   }
66268
66269 }
66270
66271
66272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66273   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66274   Dali::Actor *arg2 = 0 ;
66275
66276   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66277   arg2 = (Dali::Actor *)jarg2;
66278   if (!arg2) {
66279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
66280     return ;
66281   }
66282   {
66283     try {
66284       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
66285     } catch (std::out_of_range& e) {
66286       {
66287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66288       };
66289     } catch (std::exception& e) {
66290       {
66291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66292       };
66293     } catch (Dali::DaliException e) {
66294       {
66295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66296       };
66297     } catch (...) {
66298       {
66299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66300       };
66301     }
66302   }
66303
66304 }
66305
66306
66307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
66308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66309   Dali::Toolkit::StyleManager arg2 ;
66310   Dali::StyleChange::Type arg3 ;
66311   Dali::Toolkit::StyleManager *argp2 ;
66312
66313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66314   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66315   if (!argp2) {
66316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66317     return ;
66318   }
66319   arg2 = *argp2;
66320   arg3 = (Dali::StyleChange::Type)jarg3;
66321   {
66322     try {
66323       (arg1)->OnStyleChange(arg2,arg3);
66324     } catch (std::out_of_range& e) {
66325       {
66326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66327       };
66328     } catch (std::exception& e) {
66329       {
66330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66331       };
66332     } catch (Dali::DaliException e) {
66333       {
66334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66335       };
66336     } catch (...) {
66337       {
66338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66339       };
66340     }
66341   }
66342
66343 }
66344
66345
66346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
66347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66348   Dali::Toolkit::StyleManager arg2 ;
66349   Dali::StyleChange::Type arg3 ;
66350   Dali::Toolkit::StyleManager *argp2 ;
66351
66352   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66353   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
66354   if (!argp2) {
66355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
66356     return ;
66357   }
66358   arg2 = *argp2;
66359   arg3 = (Dali::StyleChange::Type)jarg3;
66360   {
66361     try {
66362       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
66363     } catch (std::out_of_range& e) {
66364       {
66365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66366       };
66367     } catch (std::exception& e) {
66368       {
66369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66370       };
66371     } catch (Dali::DaliException e) {
66372       {
66373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66374       };
66375     } catch (...) {
66376       {
66377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66378       };
66379     }
66380   }
66381
66382 }
66383
66384
66385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
66386   unsigned int jresult ;
66387   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66388   bool result;
66389
66390   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66391   {
66392     try {
66393       result = (bool)(arg1)->OnAccessibilityActivated();
66394     } catch (std::out_of_range& e) {
66395       {
66396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66397       };
66398     } catch (std::exception& e) {
66399       {
66400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66401       };
66402     } catch (Dali::DaliException e) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66405       };
66406     } catch (...) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66409       };
66410     }
66411   }
66412
66413   jresult = result;
66414   return jresult;
66415 }
66416
66417
66418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
66419   unsigned int jresult ;
66420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66421   bool result;
66422
66423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66424   {
66425     try {
66426       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
66427     } catch (std::out_of_range& e) {
66428       {
66429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66430       };
66431     } catch (std::exception& e) {
66432       {
66433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66434       };
66435     } catch (Dali::DaliException e) {
66436       {
66437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66438       };
66439     } catch (...) {
66440       {
66441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66442       };
66443     }
66444   }
66445
66446   jresult = result;
66447   return jresult;
66448 }
66449
66450
66451 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
66452   unsigned int jresult ;
66453   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66454   Dali::PanGesture arg2 ;
66455   Dali::PanGesture *argp2 ;
66456   bool result;
66457
66458   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66459   argp2 = (Dali::PanGesture *)jarg2;
66460   if (!argp2) {
66461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66462     return 0;
66463   }
66464   arg2 = *argp2;
66465   {
66466     try {
66467       result = (bool)(arg1)->OnAccessibilityPan(arg2);
66468     } catch (std::out_of_range& e) {
66469       {
66470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66471       };
66472     } catch (std::exception& e) {
66473       {
66474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66475       };
66476     } catch (Dali::DaliException e) {
66477       {
66478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66479       };
66480     } catch (...) {
66481       {
66482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66483       };
66484     }
66485   }
66486
66487   jresult = result;
66488   return jresult;
66489 }
66490
66491
66492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66493   unsigned int jresult ;
66494   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66495   Dali::PanGesture arg2 ;
66496   Dali::PanGesture *argp2 ;
66497   bool result;
66498
66499   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66500   argp2 = (Dali::PanGesture *)jarg2;
66501   if (!argp2) {
66502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
66503     return 0;
66504   }
66505   arg2 = *argp2;
66506   {
66507     try {
66508       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
66509     } catch (std::out_of_range& e) {
66510       {
66511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66512       };
66513     } catch (std::exception& e) {
66514       {
66515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66516       };
66517     } catch (Dali::DaliException e) {
66518       {
66519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66520       };
66521     } catch (...) {
66522       {
66523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66524       };
66525     }
66526   }
66527
66528   jresult = result;
66529   return jresult;
66530 }
66531
66532
66533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
66534   unsigned int jresult ;
66535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66536   Dali::TouchEvent *arg2 = 0 ;
66537   bool result;
66538
66539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66540   arg2 = (Dali::TouchEvent *)jarg2;
66541   if (!arg2) {
66542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66543     return 0;
66544   }
66545   {
66546     try {
66547       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66548     } catch (std::out_of_range& e) {
66549       {
66550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66551       };
66552     } catch (std::exception& e) {
66553       {
66554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66555       };
66556     } catch (Dali::DaliException e) {
66557       {
66558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66559       };
66560     } catch (...) {
66561       {
66562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66563       };
66564     }
66565   }
66566
66567   jresult = result;
66568   return jresult;
66569 }
66570
66571
66572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66573   unsigned int jresult ;
66574   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66575   Dali::TouchEvent *arg2 = 0 ;
66576   bool result;
66577
66578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66579   arg2 = (Dali::TouchEvent *)jarg2;
66580   if (!arg2) {
66581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
66582     return 0;
66583   }
66584   {
66585     try {
66586       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
66587     } catch (std::out_of_range& e) {
66588       {
66589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66590       };
66591     } catch (std::exception& e) {
66592       {
66593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66594       };
66595     } catch (Dali::DaliException e) {
66596       {
66597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66598       };
66599     } catch (...) {
66600       {
66601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66602       };
66603     }
66604   }
66605
66606   jresult = result;
66607   return jresult;
66608 }
66609
66610
66611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66612   unsigned int jresult ;
66613   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66614   bool arg2 ;
66615   bool result;
66616
66617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66618   arg2 = jarg2 ? true : false;
66619   {
66620     try {
66621       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66622     } catch (std::out_of_range& e) {
66623       {
66624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66625       };
66626     } catch (std::exception& e) {
66627       {
66628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66629       };
66630     } catch (Dali::DaliException e) {
66631       {
66632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66633       };
66634     } catch (...) {
66635       {
66636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66637       };
66638     }
66639   }
66640
66641   jresult = result;
66642   return jresult;
66643 }
66644
66645
66646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66647   unsigned int jresult ;
66648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66649   bool arg2 ;
66650   bool result;
66651
66652   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66653   arg2 = jarg2 ? true : false;
66654   {
66655     try {
66656       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66657     } catch (std::out_of_range& e) {
66658       {
66659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66660       };
66661     } catch (std::exception& e) {
66662       {
66663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66664       };
66665     } catch (Dali::DaliException e) {
66666       {
66667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66668       };
66669     } catch (...) {
66670       {
66671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66672       };
66673     }
66674   }
66675
66676   jresult = result;
66677   return jresult;
66678 }
66679
66680
66681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66682   unsigned int jresult ;
66683   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66684   bool result;
66685
66686   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66687   {
66688     try {
66689       result = (bool)(arg1)->OnAccessibilityZoom();
66690     } catch (std::out_of_range& e) {
66691       {
66692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66693       };
66694     } catch (std::exception& e) {
66695       {
66696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66697       };
66698     } catch (Dali::DaliException e) {
66699       {
66700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66701       };
66702     } catch (...) {
66703       {
66704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66705       };
66706     }
66707   }
66708
66709   jresult = result;
66710   return jresult;
66711 }
66712
66713
66714 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66715   unsigned int jresult ;
66716   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66717   bool result;
66718
66719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66720   {
66721     try {
66722       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66723     } catch (std::out_of_range& e) {
66724       {
66725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66726       };
66727     } catch (std::exception& e) {
66728       {
66729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66730       };
66731     } catch (Dali::DaliException e) {
66732       {
66733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66734       };
66735     } catch (...) {
66736       {
66737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66738       };
66739     }
66740   }
66741
66742   jresult = result;
66743   return jresult;
66744 }
66745
66746
66747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(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)->OnKeyInputFocusGained();
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_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66778
66779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66780   {
66781     try {
66782       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66783     } catch (std::out_of_range& e) {
66784       {
66785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66786       };
66787     } catch (std::exception& e) {
66788       {
66789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66790       };
66791     } catch (Dali::DaliException e) {
66792       {
66793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66794       };
66795     } catch (...) {
66796       {
66797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66798       };
66799     }
66800   }
66801
66802 }
66803
66804
66805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66807
66808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66809   {
66810     try {
66811       (arg1)->OnKeyInputFocusLost();
66812     } catch (std::out_of_range& e) {
66813       {
66814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66815       };
66816     } catch (std::exception& e) {
66817       {
66818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66819       };
66820     } catch (Dali::DaliException e) {
66821       {
66822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66823       };
66824     } catch (...) {
66825       {
66826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66827       };
66828     }
66829   }
66830
66831 }
66832
66833
66834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66835   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66836
66837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66838   {
66839     try {
66840       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66841     } catch (std::out_of_range& e) {
66842       {
66843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66844       };
66845     } catch (std::exception& e) {
66846       {
66847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66848       };
66849     } catch (Dali::DaliException e) {
66850       {
66851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66852       };
66853     } catch (...) {
66854       {
66855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66856       };
66857     }
66858   }
66859
66860 }
66861
66862
66863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66864   void * jresult ;
66865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66866   Dali::Actor arg2 ;
66867   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66868   bool arg4 ;
66869   Dali::Actor *argp2 ;
66870   Dali::Actor result;
66871
66872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66873   argp2 = (Dali::Actor *)jarg2;
66874   if (!argp2) {
66875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66876     return 0;
66877   }
66878   arg2 = *argp2;
66879   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66880   arg4 = jarg4 ? true : false;
66881   {
66882     try {
66883       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66884     } catch (std::out_of_range& e) {
66885       {
66886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (std::exception& e) {
66889       {
66890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66891       };
66892     } catch (Dali::DaliException e) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66895       };
66896     } catch (...) {
66897       {
66898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66899       };
66900     }
66901   }
66902
66903   jresult = new Dali::Actor((const Dali::Actor &)result);
66904   return jresult;
66905 }
66906
66907
66908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66909   void * jresult ;
66910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66911   Dali::Actor arg2 ;
66912   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66913   bool arg4 ;
66914   Dali::Actor *argp2 ;
66915   Dali::Actor result;
66916
66917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66918   argp2 = (Dali::Actor *)jarg2;
66919   if (!argp2) {
66920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66921     return 0;
66922   }
66923   arg2 = *argp2;
66924   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66925   arg4 = jarg4 ? true : false;
66926   {
66927     try {
66928       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66929     } catch (std::out_of_range& e) {
66930       {
66931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66932       };
66933     } catch (std::exception& e) {
66934       {
66935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66936       };
66937     } catch (Dali::DaliException e) {
66938       {
66939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66940       };
66941     } catch (...) {
66942       {
66943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66944       };
66945     }
66946   }
66947
66948   jresult = new Dali::Actor((const Dali::Actor &)result);
66949   return jresult;
66950 }
66951
66952
66953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66954   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66955   Dali::Actor arg2 ;
66956   Dali::Actor *argp2 ;
66957
66958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66959   argp2 = (Dali::Actor *)jarg2;
66960   if (!argp2) {
66961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66962     return ;
66963   }
66964   arg2 = *argp2;
66965   {
66966     try {
66967       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66968     } catch (std::out_of_range& e) {
66969       {
66970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66971       };
66972     } catch (std::exception& e) {
66973       {
66974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66975       };
66976     } catch (Dali::DaliException e) {
66977       {
66978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66979       };
66980     } catch (...) {
66981       {
66982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66983       };
66984     }
66985   }
66986
66987 }
66988
66989
66990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66991   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66992   Dali::Actor arg2 ;
66993   Dali::Actor *argp2 ;
66994
66995   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66996   argp2 = (Dali::Actor *)jarg2;
66997   if (!argp2) {
66998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66999     return ;
67000   }
67001   arg2 = *argp2;
67002   {
67003     try {
67004       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
67005     } catch (std::out_of_range& e) {
67006       {
67007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67008       };
67009     } catch (std::exception& e) {
67010       {
67011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67012       };
67013     } catch (Dali::DaliException e) {
67014       {
67015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67016       };
67017     } catch (...) {
67018       {
67019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67020       };
67021     }
67022   }
67023
67024 }
67025
67026
67027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
67028   unsigned int jresult ;
67029   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67030   bool result;
67031
67032   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67033   {
67034     try {
67035       result = (bool)(arg1)->OnKeyboardEnter();
67036     } catch (std::out_of_range& e) {
67037       {
67038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (std::exception& e) {
67041       {
67042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (Dali::DaliException e) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67047       };
67048     } catch (...) {
67049       {
67050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67051       };
67052     }
67053   }
67054
67055   jresult = result;
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
67061   unsigned int jresult ;
67062   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67063   bool result;
67064
67065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67066   {
67067     try {
67068       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
67069     } catch (std::out_of_range& e) {
67070       {
67071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67072       };
67073     } catch (std::exception& e) {
67074       {
67075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67076       };
67077     } catch (Dali::DaliException e) {
67078       {
67079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67080       };
67081     } catch (...) {
67082       {
67083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67084       };
67085     }
67086   }
67087
67088   jresult = result;
67089   return jresult;
67090 }
67091
67092
67093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
67094   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67095   Dali::PinchGesture *arg2 = 0 ;
67096
67097   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67098   arg2 = (Dali::PinchGesture *)jarg2;
67099   if (!arg2) {
67100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67101     return ;
67102   }
67103   {
67104     try {
67105       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
67106     } catch (std::out_of_range& e) {
67107       {
67108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67109       };
67110     } catch (std::exception& e) {
67111       {
67112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67113       };
67114     } catch (Dali::DaliException e) {
67115       {
67116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67117       };
67118     } catch (...) {
67119       {
67120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67121       };
67122     }
67123   }
67124
67125 }
67126
67127
67128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67129   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67130   Dali::PinchGesture *arg2 = 0 ;
67131
67132   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67133   arg2 = (Dali::PinchGesture *)jarg2;
67134   if (!arg2) {
67135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
67136     return ;
67137   }
67138   {
67139     try {
67140       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
67141     } catch (std::out_of_range& e) {
67142       {
67143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67144       };
67145     } catch (std::exception& e) {
67146       {
67147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67148       };
67149     } catch (Dali::DaliException e) {
67150       {
67151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67152       };
67153     } catch (...) {
67154       {
67155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67156       };
67157     }
67158   }
67159
67160 }
67161
67162
67163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
67164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67165   Dali::PanGesture *arg2 = 0 ;
67166
67167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67168   arg2 = (Dali::PanGesture *)jarg2;
67169   if (!arg2) {
67170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67171     return ;
67172   }
67173   {
67174     try {
67175       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
67176     } catch (std::out_of_range& e) {
67177       {
67178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67179       };
67180     } catch (std::exception& e) {
67181       {
67182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67183       };
67184     } catch (Dali::DaliException e) {
67185       {
67186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67187       };
67188     } catch (...) {
67189       {
67190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67191       };
67192     }
67193   }
67194
67195 }
67196
67197
67198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67199   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67200   Dali::PanGesture *arg2 = 0 ;
67201
67202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67203   arg2 = (Dali::PanGesture *)jarg2;
67204   if (!arg2) {
67205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
67206     return ;
67207   }
67208   {
67209     try {
67210       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
67211     } catch (std::out_of_range& e) {
67212       {
67213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67214       };
67215     } catch (std::exception& e) {
67216       {
67217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67218       };
67219     } catch (Dali::DaliException e) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67222       };
67223     } catch (...) {
67224       {
67225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67226       };
67227     }
67228   }
67229
67230 }
67231
67232
67233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
67234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67235   Dali::TapGesture *arg2 = 0 ;
67236
67237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67238   arg2 = (Dali::TapGesture *)jarg2;
67239   if (!arg2) {
67240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67241     return ;
67242   }
67243   {
67244     try {
67245       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
67246     } catch (std::out_of_range& e) {
67247       {
67248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67249       };
67250     } catch (std::exception& e) {
67251       {
67252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67253       };
67254     } catch (Dali::DaliException e) {
67255       {
67256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67257       };
67258     } catch (...) {
67259       {
67260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67261       };
67262     }
67263   }
67264
67265 }
67266
67267
67268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67269   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67270   Dali::TapGesture *arg2 = 0 ;
67271
67272   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67273   arg2 = (Dali::TapGesture *)jarg2;
67274   if (!arg2) {
67275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
67276     return ;
67277   }
67278   {
67279     try {
67280       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
67281     } catch (std::out_of_range& e) {
67282       {
67283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67284       };
67285     } catch (std::exception& e) {
67286       {
67287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67288       };
67289     } catch (Dali::DaliException e) {
67290       {
67291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67292       };
67293     } catch (...) {
67294       {
67295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67296       };
67297     }
67298   }
67299
67300 }
67301
67302
67303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
67304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67305   Dali::LongPressGesture *arg2 = 0 ;
67306
67307   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67308   arg2 = (Dali::LongPressGesture *)jarg2;
67309   if (!arg2) {
67310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67311     return ;
67312   }
67313   {
67314     try {
67315       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
67316     } catch (std::out_of_range& e) {
67317       {
67318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67319       };
67320     } catch (std::exception& e) {
67321       {
67322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67323       };
67324     } catch (Dali::DaliException e) {
67325       {
67326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67327       };
67328     } catch (...) {
67329       {
67330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67331       };
67332     }
67333   }
67334
67335 }
67336
67337
67338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
67339   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67340   Dali::LongPressGesture *arg2 = 0 ;
67341
67342   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67343   arg2 = (Dali::LongPressGesture *)jarg2;
67344   if (!arg2) {
67345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
67346     return ;
67347   }
67348   {
67349     try {
67350       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
67351     } catch (std::out_of_range& e) {
67352       {
67353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67354       };
67355     } catch (std::exception& e) {
67356       {
67357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67358       };
67359     } catch (Dali::DaliException e) {
67360       {
67361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67362       };
67363     } catch (...) {
67364       {
67365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67366       };
67367     }
67368   }
67369
67370 }
67371
67372
67373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
67374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67375   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67376   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67377
67378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67379   arg2 = (Dali::SlotObserver *)jarg2;
67380   arg3 = (Dali::CallbackBase *)jarg3;
67381   {
67382     try {
67383       (arg1)->SignalConnected(arg2,arg3);
67384     } catch (std::out_of_range& e) {
67385       {
67386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67387       };
67388     } catch (std::exception& e) {
67389       {
67390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67391       };
67392     } catch (Dali::DaliException e) {
67393       {
67394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67395       };
67396     } catch (...) {
67397       {
67398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67399       };
67400     }
67401   }
67402
67403 }
67404
67405
67406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67407   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67408   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67409   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67410
67411   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67412   arg2 = (Dali::SlotObserver *)jarg2;
67413   arg3 = (Dali::CallbackBase *)jarg3;
67414   {
67415     try {
67416       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
67417     } catch (std::out_of_range& e) {
67418       {
67419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67420       };
67421     } catch (std::exception& e) {
67422       {
67423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67424       };
67425     } catch (Dali::DaliException e) {
67426       {
67427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67428       };
67429     } catch (...) {
67430       {
67431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67432       };
67433     }
67434   }
67435
67436 }
67437
67438
67439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
67440   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67441   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67442   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67443
67444   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67445   arg2 = (Dali::SlotObserver *)jarg2;
67446   arg3 = (Dali::CallbackBase *)jarg3;
67447   {
67448     try {
67449       (arg1)->SignalDisconnected(arg2,arg3);
67450     } catch (std::out_of_range& e) {
67451       {
67452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67453       };
67454     } catch (std::exception& e) {
67455       {
67456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67457       };
67458     } catch (Dali::DaliException e) {
67459       {
67460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67461       };
67462     } catch (...) {
67463       {
67464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67465       };
67466     }
67467   }
67468
67469 }
67470
67471
67472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
67473   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
67474   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
67475   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
67476
67477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67478   arg2 = (Dali::SlotObserver *)jarg2;
67479   arg3 = (Dali::CallbackBase *)jarg3;
67480   {
67481     try {
67482       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
67483     } catch (std::out_of_range& e) {
67484       {
67485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67486       };
67487     } catch (std::exception& e) {
67488       {
67489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67490       };
67491     } catch (Dali::DaliException e) {
67492       {
67493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67494       };
67495     } catch (...) {
67496       {
67497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67498       };
67499     }
67500   }
67501
67502 }
67503
67504
67505 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) {
67506   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
67507   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
67508   if (director) {
67509     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);
67510   }
67511 }
67512
67513
67514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
67515   void * jresult ;
67516   Dali::Toolkit::Control *arg1 = 0 ;
67517   Dali::Toolkit::Internal::Control *result = 0 ;
67518
67519   arg1 = (Dali::Toolkit::Control *)jarg1;
67520   if (!arg1) {
67521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67522     return 0;
67523   }
67524   {
67525     try {
67526       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
67527     } catch (std::out_of_range& e) {
67528       {
67529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (std::exception& e) {
67532       {
67533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67534       };
67535     } catch (Dali::DaliException e) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67538       };
67539     } catch (...) {
67540       {
67541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67542       };
67543     }
67544   }
67545
67546   jresult = (void *)result;
67547   return jresult;
67548 }
67549
67550
67551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
67552   int jresult ;
67553   int result;
67554
67555   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
67556   jresult = (int)result;
67557   return jresult;
67558 }
67559
67560
67561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
67562   int jresult ;
67563   int result;
67564
67565   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
67566   jresult = (int)result;
67567   return jresult;
67568 }
67569
67570
67571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
67572   int jresult ;
67573   int result;
67574
67575   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
67576   jresult = (int)result;
67577   return jresult;
67578 }
67579
67580
67581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
67582   int jresult ;
67583   int result;
67584
67585   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
67586   jresult = (int)result;
67587   return jresult;
67588 }
67589
67590
67591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
67592   int jresult ;
67593   int result;
67594
67595   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
67596   jresult = (int)result;
67597   return jresult;
67598 }
67599
67600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
67601   int jresult ;
67602   int result;
67603
67604   result = (int)Dali::Toolkit::Control::Property::MARGIN;
67605   jresult = (int)result;
67606   return jresult;
67607 }
67608
67609
67610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67611   int jresult ;
67612   int result;
67613
67614   result = (int)Dali::Toolkit::Control::Property::PADDING;
67615   jresult = (int)result;
67616   return jresult;
67617 }
67618
67619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67620   void * jresult ;
67621   Dali::Toolkit::Control::Property *result = 0 ;
67622
67623   {
67624     try {
67625       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67626     } catch (std::out_of_range& e) {
67627       {
67628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67629       };
67630     } catch (std::exception& e) {
67631       {
67632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67633       };
67634     } catch (Dali::DaliException e) {
67635       {
67636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67637       };
67638     } catch (...) {
67639       {
67640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67641       };
67642     }
67643   }
67644
67645   jresult = (void *)result;
67646   return jresult;
67647 }
67648
67649
67650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67651   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67652
67653   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67654   {
67655     try {
67656       delete arg1;
67657     } catch (std::out_of_range& e) {
67658       {
67659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67660       };
67661     } catch (std::exception& e) {
67662       {
67663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67664       };
67665     } catch (Dali::DaliException e) {
67666       {
67667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67668       };
67669     } catch (...) {
67670       {
67671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67672       };
67673     }
67674   }
67675
67676 }
67677
67678
67679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67680   void * jresult ;
67681   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67682
67683   {
67684     try {
67685       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67686     } catch (std::out_of_range& e) {
67687       {
67688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67689       };
67690     } catch (std::exception& e) {
67691       {
67692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67693       };
67694     } catch (Dali::DaliException e) {
67695       {
67696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67697       };
67698     } catch (...) {
67699       {
67700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67701       };
67702     }
67703   }
67704
67705   jresult = (void *)result;
67706   return jresult;
67707 }
67708
67709
67710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67711   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67712
67713   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67714   {
67715     try {
67716       delete arg1;
67717     } catch (std::out_of_range& e) {
67718       {
67719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67720       };
67721     } catch (std::exception& e) {
67722       {
67723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67724       };
67725     } catch (Dali::DaliException e) {
67726       {
67727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67728       };
67729     } catch (...) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67732       };
67733     }
67734   }
67735
67736 }
67737
67738
67739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67740   void * jresult ;
67741   Dali::Toolkit::Control result;
67742
67743   {
67744     try {
67745       result = Dali::Toolkit::Control::New();
67746     } catch (std::out_of_range& e) {
67747       {
67748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67749       };
67750     } catch (std::exception& e) {
67751       {
67752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67753       };
67754     } catch (Dali::DaliException e) {
67755       {
67756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67757       };
67758     } catch (...) {
67759       {
67760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67761       };
67762     }
67763   }
67764
67765   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67766   return jresult;
67767 }
67768
67769
67770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67771   void * jresult ;
67772   Dali::Toolkit::Control *result = 0 ;
67773
67774   {
67775     try {
67776       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67777     } catch (std::out_of_range& e) {
67778       {
67779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67780       };
67781     } catch (std::exception& e) {
67782       {
67783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67784       };
67785     } catch (Dali::DaliException e) {
67786       {
67787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67788       };
67789     } catch (...) {
67790       {
67791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67792       };
67793     }
67794   }
67795
67796   jresult = (void *)result;
67797   return jresult;
67798 }
67799
67800
67801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67802   void * jresult ;
67803   Dali::Toolkit::Control *arg1 = 0 ;
67804   Dali::Toolkit::Control *result = 0 ;
67805
67806   arg1 = (Dali::Toolkit::Control *)jarg1;
67807   if (!arg1) {
67808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67809     return 0;
67810   }
67811   {
67812     try {
67813       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67814     } catch (std::out_of_range& e) {
67815       {
67816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67817       };
67818     } catch (std::exception& e) {
67819       {
67820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67821       };
67822     } catch (Dali::DaliException e) {
67823       {
67824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67825       };
67826     } catch (...) {
67827       {
67828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67829       };
67830     }
67831   }
67832
67833   jresult = (void *)result;
67834   return jresult;
67835 }
67836
67837
67838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67839   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67840
67841   arg1 = (Dali::Toolkit::Control *)jarg1;
67842   {
67843     try {
67844       delete arg1;
67845     } catch (std::out_of_range& e) {
67846       {
67847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67848       };
67849     } catch (std::exception& e) {
67850       {
67851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67852       };
67853     } catch (Dali::DaliException e) {
67854       {
67855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67856       };
67857     } catch (...) {
67858       {
67859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67860       };
67861     }
67862   }
67863
67864 }
67865
67866
67867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67868   void * jresult ;
67869   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67870   Dali::Toolkit::Control *arg2 = 0 ;
67871   Dali::Toolkit::Control *result = 0 ;
67872
67873   arg1 = (Dali::Toolkit::Control *)jarg1;
67874   arg2 = (Dali::Toolkit::Control *)jarg2;
67875   if (!arg2) {
67876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67877     return 0;
67878   }
67879   {
67880     try {
67881       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67882     } catch (std::out_of_range& e) {
67883       {
67884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67885       };
67886     } catch (std::exception& e) {
67887       {
67888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67889       };
67890     } catch (Dali::DaliException e) {
67891       {
67892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67893       };
67894     } catch (...) {
67895       {
67896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67897       };
67898     }
67899   }
67900
67901   jresult = (void *)result;
67902   return jresult;
67903 }
67904
67905
67906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67907   void * jresult ;
67908   Dali::BaseHandle arg1 ;
67909   Dali::BaseHandle *argp1 ;
67910   Dali::Toolkit::Control result;
67911
67912   argp1 = (Dali::BaseHandle *)jarg1;
67913   if (!argp1) {
67914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67915     return 0;
67916   }
67917   arg1 = *argp1;
67918   {
67919     try {
67920       result = Dali::Toolkit::Control::DownCast(arg1);
67921     } catch (std::out_of_range& e) {
67922       {
67923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67924       };
67925     } catch (std::exception& e) {
67926       {
67927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (Dali::DaliException e) {
67930       {
67931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67932       };
67933     } catch (...) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67936       };
67937     }
67938   }
67939
67940   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67941   return jresult;
67942 }
67943
67944
67945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67946   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67947
67948   arg1 = (Dali::Toolkit::Control *)jarg1;
67949   {
67950     try {
67951       (arg1)->SetKeyInputFocus();
67952     } catch (std::out_of_range& e) {
67953       {
67954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67955       };
67956     } catch (std::exception& e) {
67957       {
67958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67959       };
67960     } catch (Dali::DaliException e) {
67961       {
67962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67963       };
67964     } catch (...) {
67965       {
67966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67967       };
67968     }
67969   }
67970
67971 }
67972
67973
67974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67975   unsigned int jresult ;
67976   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67977   bool result;
67978
67979   arg1 = (Dali::Toolkit::Control *)jarg1;
67980   {
67981     try {
67982       result = (bool)(arg1)->HasKeyInputFocus();
67983     } catch (std::out_of_range& e) {
67984       {
67985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67986       };
67987     } catch (std::exception& e) {
67988       {
67989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67990       };
67991     } catch (Dali::DaliException e) {
67992       {
67993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67994       };
67995     } catch (...) {
67996       {
67997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67998       };
67999     }
68000   }
68001
68002   jresult = result;
68003   return jresult;
68004 }
68005
68006
68007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
68008   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68009
68010   arg1 = (Dali::Toolkit::Control *)jarg1;
68011   {
68012     try {
68013       (arg1)->ClearKeyInputFocus();
68014     } catch (std::out_of_range& e) {
68015       {
68016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68017       };
68018     } catch (std::exception& e) {
68019       {
68020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68021       };
68022     } catch (Dali::DaliException e) {
68023       {
68024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68025       };
68026     } catch (...) {
68027       {
68028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68029       };
68030     }
68031   }
68032
68033 }
68034
68035
68036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
68037   void * jresult ;
68038   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68039   Dali::PinchGestureDetector result;
68040
68041   arg1 = (Dali::Toolkit::Control *)jarg1;
68042   {
68043     try {
68044       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
68045     } catch (std::out_of_range& e) {
68046       {
68047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68048       };
68049     } catch (std::exception& e) {
68050       {
68051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68052       };
68053     } catch (Dali::DaliException e) {
68054       {
68055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68056       };
68057     } catch (...) {
68058       {
68059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68060       };
68061     }
68062   }
68063
68064   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
68065   return jresult;
68066 }
68067
68068
68069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
68070   void * jresult ;
68071   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68072   Dali::PanGestureDetector result;
68073
68074   arg1 = (Dali::Toolkit::Control *)jarg1;
68075   {
68076     try {
68077       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
68078     } catch (std::out_of_range& e) {
68079       {
68080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68081       };
68082     } catch (std::exception& e) {
68083       {
68084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68085       };
68086     } catch (Dali::DaliException e) {
68087       {
68088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68089       };
68090     } catch (...) {
68091       {
68092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68093       };
68094     }
68095   }
68096
68097   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
68098   return jresult;
68099 }
68100
68101
68102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
68103   void * jresult ;
68104   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68105   Dali::TapGestureDetector result;
68106
68107   arg1 = (Dali::Toolkit::Control *)jarg1;
68108   {
68109     try {
68110       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (Dali::DaliException e) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68122       };
68123     } catch (...) {
68124       {
68125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68126       };
68127     }
68128   }
68129
68130   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
68131   return jresult;
68132 }
68133
68134
68135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
68136   void * jresult ;
68137   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68138   Dali::LongPressGestureDetector result;
68139
68140   arg1 = (Dali::Toolkit::Control *)jarg1;
68141   {
68142     try {
68143       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
68144     } catch (std::out_of_range& e) {
68145       {
68146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68147       };
68148     } catch (std::exception& e) {
68149       {
68150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68151       };
68152     } catch (Dali::DaliException e) {
68153       {
68154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68155       };
68156     } catch (...) {
68157       {
68158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68159       };
68160     }
68161   }
68162
68163   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
68164   return jresult;
68165 }
68166
68167
68168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
68169   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68170   std::string *arg2 = 0 ;
68171
68172   arg1 = (Dali::Toolkit::Control *)jarg1;
68173   if (!jarg2) {
68174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68175     return ;
68176   }
68177   std::string arg2_str(jarg2);
68178   arg2 = &arg2_str;
68179   {
68180     try {
68181       (arg1)->SetStyleName((std::string const &)*arg2);
68182     } catch (std::out_of_range& e) {
68183       {
68184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68185       };
68186     } catch (std::exception& e) {
68187       {
68188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68189       };
68190     } catch (Dali::DaliException e) {
68191       {
68192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68193       };
68194     } catch (...) {
68195       {
68196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68197       };
68198     }
68199   }
68200
68201
68202   //argout typemap for const std::string&
68203
68204 }
68205
68206
68207 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
68208   char * jresult ;
68209   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68210   std::string *result = 0 ;
68211
68212   arg1 = (Dali::Toolkit::Control *)jarg1;
68213   {
68214     try {
68215       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
68216     } catch (std::out_of_range& e) {
68217       {
68218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68219       };
68220     } catch (std::exception& e) {
68221       {
68222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68223       };
68224     } catch (Dali::DaliException e) {
68225       {
68226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68227       };
68228     } catch (...) {
68229       {
68230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68231       };
68232     }
68233   }
68234
68235   jresult = SWIG_csharp_string_callback(result->c_str());
68236   return jresult;
68237 }
68238
68239
68240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
68241   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68242   Dali::Vector4 *arg2 = 0 ;
68243
68244   arg1 = (Dali::Toolkit::Control *)jarg1;
68245   arg2 = (Dali::Vector4 *)jarg2;
68246   if (!arg2) {
68247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68248     return ;
68249   }
68250   {
68251     try {
68252       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
68253     } catch (std::out_of_range& e) {
68254       {
68255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68256       };
68257     } catch (std::exception& e) {
68258       {
68259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68260       };
68261     } catch (Dali::DaliException e) {
68262       {
68263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68264       };
68265     } catch (...) {
68266       {
68267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68268       };
68269     }
68270   }
68271
68272 }
68273
68274
68275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
68276   void * jresult ;
68277   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68278   Dali::Vector4 result;
68279
68280   arg1 = (Dali::Toolkit::Control *)jarg1;
68281   {
68282     try {
68283       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
68284     } catch (std::out_of_range& e) {
68285       {
68286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68287       };
68288     } catch (std::exception& e) {
68289       {
68290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68291       };
68292     } catch (Dali::DaliException e) {
68293       {
68294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68295       };
68296     } catch (...) {
68297       {
68298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68299       };
68300     }
68301   }
68302
68303   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68304   return jresult;
68305 }
68306
68307
68308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
68309   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68310   Dali::Image arg2 ;
68311   Dali::Image *argp2 ;
68312
68313   arg1 = (Dali::Toolkit::Control *)jarg1;
68314   argp2 = (Dali::Image *)jarg2;
68315   if (!argp2) {
68316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
68317     return ;
68318   }
68319   arg2 = *argp2;
68320   {
68321     try {
68322       (arg1)->SetBackgroundImage(arg2);
68323     } catch (std::out_of_range& e) {
68324       {
68325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68326       };
68327     } catch (std::exception& e) {
68328       {
68329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68330       };
68331     } catch (Dali::DaliException e) {
68332       {
68333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68334       };
68335     } catch (...) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68338       };
68339     }
68340   }
68341
68342 }
68343
68344
68345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
68346   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68347
68348   arg1 = (Dali::Toolkit::Control *)jarg1;
68349   {
68350     try {
68351       (arg1)->ClearBackground();
68352     } catch (std::out_of_range& e) {
68353       {
68354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68355       };
68356     } catch (std::exception& e) {
68357       {
68358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68359       };
68360     } catch (Dali::DaliException e) {
68361       {
68362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68363       };
68364     } catch (...) {
68365       {
68366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68367       };
68368     }
68369   }
68370
68371 }
68372
68373
68374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
68375   void * jresult ;
68376   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68377   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
68378
68379   arg1 = (Dali::Toolkit::Control *)jarg1;
68380   {
68381     try {
68382       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
68383     } catch (std::out_of_range& e) {
68384       {
68385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68386       };
68387     } catch (std::exception& e) {
68388       {
68389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68390       };
68391     } catch (Dali::DaliException e) {
68392       {
68393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68394       };
68395     } catch (...) {
68396       {
68397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68398       };
68399     }
68400   }
68401
68402   jresult = (void *)result;
68403   return jresult;
68404 }
68405
68406
68407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
68408   void * jresult ;
68409   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68410   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68411
68412   arg1 = (Dali::Toolkit::Control *)jarg1;
68413   {
68414     try {
68415       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
68416     } catch (std::out_of_range& e) {
68417       {
68418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68419       };
68420     } catch (std::exception& e) {
68421       {
68422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68423       };
68424     } catch (Dali::DaliException e) {
68425       {
68426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68427       };
68428     } catch (...) {
68429       {
68430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68431       };
68432     }
68433   }
68434
68435   jresult = (void *)result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
68441   void * jresult ;
68442   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68443   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
68444
68445   arg1 = (Dali::Toolkit::Control *)jarg1;
68446   {
68447     try {
68448       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
68449     } catch (std::out_of_range& e) {
68450       {
68451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68452       };
68453     } catch (std::exception& e) {
68454       {
68455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68456       };
68457     } catch (Dali::DaliException e) {
68458       {
68459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68460       };
68461     } catch (...) {
68462       {
68463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68464       };
68465     }
68466   }
68467
68468   jresult = (void *)result;
68469   return jresult;
68470 }
68471
68472
68473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
68474   void * jresult ;
68475   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68476   Dali::Toolkit::Control *result = 0 ;
68477
68478   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68479   if (!arg1) {
68480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68481     return 0;
68482   }
68483   {
68484     try {
68485       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
68486     } catch (std::out_of_range& e) {
68487       {
68488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68489       };
68490     } catch (std::exception& e) {
68491       {
68492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68493       };
68494     } catch (Dali::DaliException e) {
68495       {
68496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68497       };
68498     } catch (...) {
68499       {
68500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68501       };
68502     }
68503   }
68504
68505   jresult = (void *)result;
68506   return jresult;
68507 }
68508
68509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
68510 {
68511   int jresult;
68512   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68513   arg1 = (Dali::Toolkit::Control *)jarg1;
68514
68515   if (!arg1) {
68516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68517     return 0;
68518   }
68519
68520   Dali::Property::Index arg2 = 0 ;
68521   arg2 = (Dali::Property::Index)jarg2;
68522
68523   Toolkit::Visual::ResourceStatus result;
68524   {
68525     try {
68526       result = arg1->GetVisualResourceStatus(arg2);
68527     } catch (std::out_of_range& e) {
68528       {
68529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (std::exception& e) {
68532       {
68533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68538       };
68539     }
68540   }
68541   jresult = (int)(result);
68542   return jresult;
68543 }
68544
68545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
68546 {
68547   void * jresult;
68548   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
68549   arg1 = (Dali::Toolkit::Control *)jarg1;
68550
68551   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
68552
68553   Dali::Toolkit::TransitionData *arg2 = 0 ;
68554   Dali::Animation result;
68555
68556   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
68557   if (!arg2) {
68558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
68559     return 0;
68560   }
68561   {
68562     try {
68563       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
68564     } catch (std::out_of_range& e) {
68565       {
68566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (std::exception& e) {
68569       {
68570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68571       };
68572     } catch (Dali::DaliException e) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68575       };
68576     } catch (...) {
68577       {
68578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68579       };
68580     }
68581   }
68582
68583   jresult = new Dali::Animation((const Dali::Animation &)result);
68584   return jresult;
68585 }
68586
68587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
68588 {
68589   Dali::Toolkit::Control arg1;
68590   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
68591
68592   if (!argp1) {
68593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68594   }
68595   arg1 = *argp1;
68596
68597   Dali::Property::Index arg2 = 0 ;
68598   arg2 = (Dali::Property::Index)jarg2;
68599
68600   Dali::Property::Index arg3 = 0 ;
68601   arg3 = (Dali::Property::Index)jarg3;
68602
68603   Dali::Property::Value arg4;
68604   arg4 = (Dali::Property::Value *)jarg4;
68605
68606   {
68607     try {
68608       DevelControl::DoAction(arg1, arg2, arg3, arg4);
68609     } catch (std::out_of_range& e) {
68610       {
68611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68612       };
68613     } catch (std::exception& e) {
68614       {
68615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68616       };
68617     } catch (...) {
68618       {
68619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68620       };
68621     }
68622   }
68623
68624
68625 }
68626
68627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_0(void * jarg1) {
68628   void * jresult ;
68629   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68630   Dali::Toolkit::LayoutItem result;
68631
68632   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68633   if (!arg1) {
68634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68635     return 0;
68636   }
68637   {
68638     try {
68639       result = Dali::Toolkit::DevelControl::GetLayout(*arg1);
68640     } catch (std::out_of_range& e) {
68641       {
68642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68643       };
68644     } catch (std::exception& e) {
68645       {
68646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68647       };
68648     } catch (...) {
68649       {
68650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68651       };
68652     }
68653   }
68654   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68655   return jresult;
68656 }
68657
68658
68659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetLayout__SWIG_1(void * jarg1) {
68660   void * jresult ;
68661   Dali::Toolkit::Control arg1 ;
68662   Dali::Toolkit::Control *argp1 ;
68663   Dali::Toolkit::LayoutItem result;
68664
68665   argp1 = (Dali::Toolkit::Control *)jarg1;
68666   if (!argp1) {
68667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68668     return 0;
68669   }
68670   arg1 = *argp1;
68671   {
68672     try {
68673       result = Dali::Toolkit::DevelControl::GetLayout(arg1);
68674     } catch (std::out_of_range& e) {
68675       {
68676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68677       };
68678     } catch (std::exception& e) {
68679       {
68680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68681       };
68682     } catch (...) {
68683       {
68684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68685       };
68686     }
68687   }
68688   jresult = new Dali::Toolkit::LayoutItem((const Dali::Toolkit::LayoutItem &)result);
68689   return jresult;
68690 }
68691
68692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_0(void * jarg1, void * jarg2) {
68693   Dali::Toolkit::Internal::Control *arg1 = 0 ;
68694   Dali::Toolkit::LayoutItem arg2 ;
68695   Dali::Toolkit::LayoutItem *argp2 ;
68696
68697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
68698   if (!arg1) {
68699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
68700     return ;
68701   }
68702   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68703   if (!argp2) {
68704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68705     return ;
68706   }
68707   arg2 = *argp2;
68708   {
68709     try {
68710       Dali::Toolkit::DevelControl::SetLayout(*arg1,arg2);
68711     } catch (std::out_of_range& e) {
68712       {
68713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68714       };
68715     } catch (std::exception& e) {
68716       {
68717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68718       };
68719     } catch (...) {
68720       {
68721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68722       };
68723     }
68724   }
68725 }
68726
68727
68728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetLayout__SWIG_1(void * jarg1, void * jarg2) {
68729   Dali::Toolkit::Control arg1 ;
68730   Dali::Toolkit::LayoutItem arg2 ;
68731   Dali::Toolkit::Control *argp1 ;
68732   Dali::Toolkit::LayoutItem *argp2 ;
68733
68734   argp1 = (Dali::Toolkit::Control *)jarg1;
68735   if (!argp1) {
68736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68737     return ;
68738   }
68739   arg1 = *argp1;
68740   argp2 = (Dali::Toolkit::LayoutItem *)jarg2;
68741   if (!argp2) {
68742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::LayoutItem", 0);
68743     return ;
68744   }
68745   arg2 = *argp2;
68746   {
68747     try {
68748       Dali::Toolkit::DevelControl::SetLayout(arg1,arg2);
68749     } catch (std::out_of_range& e) {
68750       {
68751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68752       };
68753     } catch (std::exception& e) {
68754       {
68755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68756       };
68757     } catch (...) {
68758       {
68759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68760       };
68761     }
68762   }
68763 }
68764
68765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68766   void * jresult ;
68767   Dali::Toolkit::Control *arg1 = 0 ;
68768   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68769
68770   arg1 = (Dali::Toolkit::Control *)jarg1;
68771   if (!arg1) {
68772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68773     return 0;
68774   }
68775   {
68776     try {
68777       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68778     } catch (std::out_of_range& e) {
68779       {
68780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68781       };
68782     } catch (std::exception& e) {
68783       {
68784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68785       };
68786     } catch (Dali::DaliException e) {
68787       {
68788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68789       };
68790     } catch (...) {
68791       {
68792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68793       };
68794     }
68795   }
68796
68797   jresult = (void *)result;
68798   return jresult;
68799 }
68800
68801
68802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68803   unsigned int jresult ;
68804   Dali::Toolkit::Control *arg1 = 0 ;
68805   bool result;
68806
68807   arg1 = (Dali::Toolkit::Control *)jarg1;
68808   if (!arg1) {
68809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68810     return 0;
68811   }
68812   {
68813     try {
68814       result = (bool)arg1->IsResourceReady();
68815     } catch (std::out_of_range& e) {
68816       {
68817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68818       };
68819     } catch (std::exception& e) {
68820       {
68821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68822       };
68823     } catch (Dali::DaliException e) {
68824       {
68825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68826       };
68827     } catch (...) {
68828       {
68829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68830       };
68831     }
68832   }
68833
68834   jresult = result;
68835   return jresult;
68836 }
68837
68838
68839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68840   void * jresult ;
68841   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68842
68843   {
68844     try {
68845       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68846     } catch (std::out_of_range& e) {
68847       {
68848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68849       };
68850     } catch (std::exception& e) {
68851       {
68852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68853       };
68854     } catch (Dali::DaliException e) {
68855       {
68856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68857       };
68858     } catch (...) {
68859       {
68860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68861       };
68862     }
68863   }
68864
68865   jresult = (void *)result;
68866   return jresult;
68867 }
68868
68869
68870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68871   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68872
68873   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68874   {
68875     try {
68876       delete arg1;
68877     } catch (std::out_of_range& e) {
68878       {
68879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68880       };
68881     } catch (std::exception& e) {
68882       {
68883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68884       };
68885     } catch (Dali::DaliException e) {
68886       {
68887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68888       };
68889     } catch (...) {
68890       {
68891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68892       };
68893     }
68894   }
68895
68896 }
68897
68898
68899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68900   void * jresult ;
68901   Dali::Toolkit::KeyInputFocusManager result;
68902
68903   {
68904     try {
68905       result = Dali::Toolkit::KeyInputFocusManager::Get();
68906     } catch (std::out_of_range& e) {
68907       {
68908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68909       };
68910     } catch (std::exception& e) {
68911       {
68912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68913       };
68914     } catch (Dali::DaliException e) {
68915       {
68916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68917       };
68918     } catch (...) {
68919       {
68920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68921       };
68922     }
68923   }
68924
68925   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68926   return jresult;
68927 }
68928
68929
68930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68931   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68932   Dali::Toolkit::Control arg2 ;
68933   Dali::Toolkit::Control *argp2 ;
68934
68935   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68936   argp2 = (Dali::Toolkit::Control *)jarg2;
68937   if (!argp2) {
68938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68939     return ;
68940   }
68941   arg2 = *argp2;
68942   {
68943     try {
68944       (arg1)->SetFocus(arg2);
68945     } catch (std::out_of_range& e) {
68946       {
68947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68948       };
68949     } catch (std::exception& e) {
68950       {
68951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68952       };
68953     } catch (Dali::DaliException e) {
68954       {
68955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68956       };
68957     } catch (...) {
68958       {
68959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68960       };
68961     }
68962   }
68963
68964 }
68965
68966
68967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68968   void * jresult ;
68969   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68970   Dali::Toolkit::Control result;
68971
68972   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68973   {
68974     try {
68975       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68976     } catch (std::out_of_range& e) {
68977       {
68978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68979       };
68980     } catch (std::exception& e) {
68981       {
68982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68983       };
68984     } catch (Dali::DaliException e) {
68985       {
68986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68987       };
68988     } catch (...) {
68989       {
68990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68991       };
68992     }
68993   }
68994
68995   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68996   return jresult;
68997 }
68998
68999
69000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
69001   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69002   Dali::Toolkit::Control arg2 ;
69003   Dali::Toolkit::Control *argp2 ;
69004
69005   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69006   argp2 = (Dali::Toolkit::Control *)jarg2;
69007   if (!argp2) {
69008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
69009     return ;
69010   }
69011   arg2 = *argp2;
69012   {
69013     try {
69014       (arg1)->RemoveFocus(arg2);
69015     } catch (std::out_of_range& e) {
69016       {
69017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69018       };
69019     } catch (std::exception& e) {
69020       {
69021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69022       };
69023     } catch (Dali::DaliException e) {
69024       {
69025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69026       };
69027     } catch (...) {
69028       {
69029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69030       };
69031     }
69032   }
69033
69034 }
69035
69036
69037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
69038   void * jresult ;
69039   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
69040   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
69041
69042   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
69043   {
69044     try {
69045       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
69046     } catch (std::out_of_range& e) {
69047       {
69048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (std::exception& e) {
69051       {
69052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (Dali::DaliException e) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69057       };
69058     } catch (...) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69061       };
69062     }
69063   }
69064
69065   jresult = (void *)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
69071   void * jresult ;
69072   Dali::Toolkit::Alignment::Padding *result = 0 ;
69073
69074   {
69075     try {
69076       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
69077     } catch (std::out_of_range& e) {
69078       {
69079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69080       };
69081     } catch (std::exception& e) {
69082       {
69083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69084       };
69085     } catch (Dali::DaliException e) {
69086       {
69087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69088       };
69089     } catch (...) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69092       };
69093     }
69094   }
69095
69096   jresult = (void *)result;
69097   return jresult;
69098 }
69099
69100
69101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
69102   void * jresult ;
69103   float arg1 ;
69104   float arg2 ;
69105   float arg3 ;
69106   float arg4 ;
69107   Dali::Toolkit::Alignment::Padding *result = 0 ;
69108
69109   arg1 = (float)jarg1;
69110   arg2 = (float)jarg2;
69111   arg3 = (float)jarg3;
69112   arg4 = (float)jarg4;
69113   {
69114     try {
69115       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
69116     } catch (std::out_of_range& e) {
69117       {
69118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69119       };
69120     } catch (std::exception& e) {
69121       {
69122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69123       };
69124     } catch (Dali::DaliException e) {
69125       {
69126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69127       };
69128     } catch (...) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69131       };
69132     }
69133   }
69134
69135   jresult = (void *)result;
69136   return jresult;
69137 }
69138
69139
69140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
69141   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69142   float arg2 ;
69143
69144   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69145   arg2 = (float)jarg2;
69146   if (arg1) (arg1)->left = arg2;
69147 }
69148
69149
69150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
69151   float jresult ;
69152   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69153   float result;
69154
69155   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69156   result = (float) ((arg1)->left);
69157   jresult = result;
69158   return jresult;
69159 }
69160
69161
69162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
69163   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69164   float arg2 ;
69165
69166   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69167   arg2 = (float)jarg2;
69168   if (arg1) (arg1)->right = arg2;
69169 }
69170
69171
69172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
69173   float jresult ;
69174   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69175   float result;
69176
69177   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69178   result = (float) ((arg1)->right);
69179   jresult = result;
69180   return jresult;
69181 }
69182
69183
69184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
69185   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69186   float arg2 ;
69187
69188   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69189   arg2 = (float)jarg2;
69190   if (arg1) (arg1)->top = arg2;
69191 }
69192
69193
69194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
69195   float jresult ;
69196   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69197   float result;
69198
69199   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69200   result = (float) ((arg1)->top);
69201   jresult = result;
69202   return jresult;
69203 }
69204
69205
69206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
69207   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69208   float arg2 ;
69209
69210   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69211   arg2 = (float)jarg2;
69212   if (arg1) (arg1)->bottom = arg2;
69213 }
69214
69215
69216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
69217   float jresult ;
69218   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69219   float result;
69220
69221   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69222   result = (float) ((arg1)->bottom);
69223   jresult = result;
69224   return jresult;
69225 }
69226
69227
69228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
69229   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
69230
69231   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
69232   {
69233     try {
69234       delete arg1;
69235     } catch (std::out_of_range& e) {
69236       {
69237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69238       };
69239     } catch (std::exception& e) {
69240       {
69241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69242       };
69243     } catch (Dali::DaliException e) {
69244       {
69245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69246       };
69247     } catch (...) {
69248       {
69249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69250       };
69251     }
69252   }
69253
69254 }
69255
69256
69257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
69258   void * jresult ;
69259   Dali::Toolkit::Alignment *result = 0 ;
69260
69261   {
69262     try {
69263       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
69264     } catch (std::out_of_range& e) {
69265       {
69266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69267       };
69268     } catch (std::exception& e) {
69269       {
69270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69271       };
69272     } catch (Dali::DaliException e) {
69273       {
69274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69275       };
69276     } catch (...) {
69277       {
69278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69279       };
69280     }
69281   }
69282
69283   jresult = (void *)result;
69284   return jresult;
69285 }
69286
69287
69288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
69289   void * jresult ;
69290   Dali::Toolkit::Alignment::Type arg1 ;
69291   Dali::Toolkit::Alignment::Type arg2 ;
69292   Dali::Toolkit::Alignment result;
69293
69294   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69295   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69296   {
69297     try {
69298       result = Dali::Toolkit::Alignment::New(arg1,arg2);
69299     } catch (std::out_of_range& e) {
69300       {
69301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69302       };
69303     } catch (std::exception& e) {
69304       {
69305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69306       };
69307     } catch (Dali::DaliException e) {
69308       {
69309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69310       };
69311     } catch (...) {
69312       {
69313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69314       };
69315     }
69316   }
69317
69318   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69319   return jresult;
69320 }
69321
69322
69323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
69324   void * jresult ;
69325   Dali::Toolkit::Alignment::Type arg1 ;
69326   Dali::Toolkit::Alignment result;
69327
69328   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
69329   {
69330     try {
69331       result = Dali::Toolkit::Alignment::New(arg1);
69332     } catch (std::out_of_range& e) {
69333       {
69334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69335       };
69336     } catch (std::exception& e) {
69337       {
69338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69339       };
69340     } catch (Dali::DaliException e) {
69341       {
69342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69343       };
69344     } catch (...) {
69345       {
69346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69347       };
69348     }
69349   }
69350
69351   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69352   return jresult;
69353 }
69354
69355
69356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
69357   void * jresult ;
69358   Dali::Toolkit::Alignment result;
69359
69360   {
69361     try {
69362       result = Dali::Toolkit::Alignment::New();
69363     } catch (std::out_of_range& e) {
69364       {
69365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69366       };
69367     } catch (std::exception& e) {
69368       {
69369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69370       };
69371     } catch (Dali::DaliException e) {
69372       {
69373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69374       };
69375     } catch (...) {
69376       {
69377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69378       };
69379     }
69380   }
69381
69382   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69383   return jresult;
69384 }
69385
69386
69387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
69388   void * jresult ;
69389   Dali::Toolkit::Alignment *arg1 = 0 ;
69390   Dali::Toolkit::Alignment *result = 0 ;
69391
69392   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69393   if (!arg1) {
69394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69395     return 0;
69396   }
69397   {
69398     try {
69399       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
69400     } catch (std::out_of_range& e) {
69401       {
69402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69403       };
69404     } catch (std::exception& e) {
69405       {
69406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69407       };
69408     } catch (Dali::DaliException e) {
69409       {
69410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69411       };
69412     } catch (...) {
69413       {
69414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69415       };
69416     }
69417   }
69418
69419   jresult = (void *)result;
69420   return jresult;
69421 }
69422
69423
69424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
69425   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69426
69427   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69428   {
69429     try {
69430       delete arg1;
69431     } catch (std::out_of_range& e) {
69432       {
69433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69434       };
69435     } catch (std::exception& e) {
69436       {
69437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69438       };
69439     } catch (Dali::DaliException e) {
69440       {
69441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69442       };
69443     } catch (...) {
69444       {
69445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69446       };
69447     }
69448   }
69449
69450 }
69451
69452
69453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
69454   void * jresult ;
69455   Dali::BaseHandle arg1 ;
69456   Dali::BaseHandle *argp1 ;
69457   Dali::Toolkit::Alignment result;
69458
69459   argp1 = (Dali::BaseHandle *)jarg1;
69460   if (!argp1) {
69461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69462     return 0;
69463   }
69464   arg1 = *argp1;
69465   {
69466     try {
69467       result = Dali::Toolkit::Alignment::DownCast(arg1);
69468     } catch (std::out_of_range& e) {
69469       {
69470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69471       };
69472     } catch (std::exception& e) {
69473       {
69474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69475       };
69476     } catch (Dali::DaliException e) {
69477       {
69478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69479       };
69480     } catch (...) {
69481       {
69482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69483       };
69484     }
69485   }
69486
69487   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
69488   return jresult;
69489 }
69490
69491
69492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
69493   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69494   Dali::Toolkit::Alignment::Type arg2 ;
69495
69496   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69497   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
69498   {
69499     try {
69500       (arg1)->SetAlignmentType(arg2);
69501     } catch (std::out_of_range& e) {
69502       {
69503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69504       };
69505     } catch (std::exception& e) {
69506       {
69507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69508       };
69509     } catch (Dali::DaliException e) {
69510       {
69511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69512       };
69513     } catch (...) {
69514       {
69515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69516       };
69517     }
69518   }
69519
69520 }
69521
69522
69523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
69524   int jresult ;
69525   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69526   Dali::Toolkit::Alignment::Type result;
69527
69528   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69529   {
69530     try {
69531       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
69532     } catch (std::out_of_range& e) {
69533       {
69534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69535       };
69536     } catch (std::exception& e) {
69537       {
69538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69539       };
69540     } catch (Dali::DaliException e) {
69541       {
69542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69543       };
69544     } catch (...) {
69545       {
69546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69547       };
69548     }
69549   }
69550
69551   jresult = (int)result;
69552   return jresult;
69553 }
69554
69555
69556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
69557   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69558   Dali::Toolkit::Alignment::Scaling arg2 ;
69559
69560   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69561   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
69562   {
69563     try {
69564       (arg1)->SetScaling(arg2);
69565     } catch (std::out_of_range& e) {
69566       {
69567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69568       };
69569     } catch (std::exception& e) {
69570       {
69571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69572       };
69573     } catch (Dali::DaliException e) {
69574       {
69575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69576       };
69577     } catch (...) {
69578       {
69579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69580       };
69581     }
69582   }
69583
69584 }
69585
69586
69587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
69588   int jresult ;
69589   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69590   Dali::Toolkit::Alignment::Scaling result;
69591
69592   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69593   {
69594     try {
69595       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
69596     } catch (std::out_of_range& e) {
69597       {
69598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69599       };
69600     } catch (std::exception& e) {
69601       {
69602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69603       };
69604     } catch (Dali::DaliException e) {
69605       {
69606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69607       };
69608     } catch (...) {
69609       {
69610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69611       };
69612     }
69613   }
69614
69615   jresult = (int)result;
69616   return jresult;
69617 }
69618
69619
69620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
69621   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69622   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
69623
69624   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69625   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
69626   if (!arg2) {
69627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
69628     return ;
69629   }
69630   {
69631     try {
69632       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
69633     } catch (std::out_of_range& e) {
69634       {
69635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69636       };
69637     } catch (std::exception& e) {
69638       {
69639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69640       };
69641     } catch (Dali::DaliException e) {
69642       {
69643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69644       };
69645     } catch (...) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69648       };
69649     }
69650   }
69651
69652 }
69653
69654
69655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
69656   void * jresult ;
69657   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69658   Dali::Toolkit::Alignment::Padding *result = 0 ;
69659
69660   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69661   {
69662     try {
69663       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
69664     } catch (std::out_of_range& e) {
69665       {
69666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69667       };
69668     } catch (std::exception& e) {
69669       {
69670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69671       };
69672     } catch (Dali::DaliException e) {
69673       {
69674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69675       };
69676     } catch (...) {
69677       {
69678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69679       };
69680     }
69681   }
69682
69683   jresult = (void *)result;
69684   return jresult;
69685 }
69686
69687
69688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
69689   void * jresult ;
69690   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
69691   Dali::Toolkit::Alignment *arg2 = 0 ;
69692   Dali::Toolkit::Alignment *result = 0 ;
69693
69694   arg1 = (Dali::Toolkit::Alignment *)jarg1;
69695   arg2 = (Dali::Toolkit::Alignment *)jarg2;
69696   if (!arg2) {
69697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
69698     return 0;
69699   }
69700   {
69701     try {
69702       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69718       };
69719     }
69720   }
69721
69722   jresult = (void *)result;
69723   return jresult;
69724 }
69725
69726
69727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
69728   int jresult ;
69729   int result;
69730
69731   result = (int)Dali::Toolkit::Button::Property::DISABLED;
69732   jresult = (int)result;
69733   return jresult;
69734 }
69735
69736
69737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
69738   int jresult ;
69739   int result;
69740
69741   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
69742   jresult = (int)result;
69743   return jresult;
69744 }
69745
69746
69747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
69748   int jresult ;
69749   int result;
69750
69751   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69752   jresult = (int)result;
69753   return jresult;
69754 }
69755
69756
69757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69758   int jresult ;
69759   int result;
69760
69761   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69762   jresult = (int)result;
69763   return jresult;
69764 }
69765
69766
69767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69768   int jresult ;
69769   int result;
69770
69771   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69772   jresult = (int)result;
69773   return jresult;
69774 }
69775
69776
69777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69778   int jresult ;
69779   int result;
69780
69781   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69782   jresult = (int)result;
69783   return jresult;
69784 }
69785
69786
69787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69788   int jresult ;
69789   int result;
69790
69791   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69792   jresult = (int)result;
69793   return jresult;
69794 }
69795
69796
69797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69798   int jresult ;
69799   int result;
69800
69801   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69802   jresult = (int)result;
69803   return jresult;
69804 }
69805
69806
69807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69808   int jresult ;
69809   int result;
69810
69811   result = (int)Dali::Toolkit::Button::Property::LABEL;
69812   jresult = (int)result;
69813   return jresult;
69814 }
69815
69816
69817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69818   int jresult ;
69819   int result;
69820
69821   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69822   jresult = (int)result;
69823   return jresult;
69824 }
69825
69826
69827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69828   void * jresult ;
69829   Dali::Toolkit::Button::Property *result = 0 ;
69830
69831   {
69832     try {
69833       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69834     } catch (std::out_of_range& e) {
69835       {
69836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69837       };
69838     } catch (std::exception& e) {
69839       {
69840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69841       };
69842     } catch (Dali::DaliException e) {
69843       {
69844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69845       };
69846     } catch (...) {
69847       {
69848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69849       };
69850     }
69851   }
69852
69853   jresult = (void *)result;
69854   return jresult;
69855 }
69856
69857
69858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69859   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69860
69861   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69862   {
69863     try {
69864       delete arg1;
69865     } catch (std::out_of_range& e) {
69866       {
69867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69868       };
69869     } catch (std::exception& e) {
69870       {
69871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69872       };
69873     } catch (Dali::DaliException e) {
69874       {
69875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69876       };
69877     } catch (...) {
69878       {
69879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69880       };
69881     }
69882   }
69883
69884 }
69885
69886
69887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69888   void * jresult ;
69889   Dali::Toolkit::Button *result = 0 ;
69890
69891   {
69892     try {
69893       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69894     } catch (std::out_of_range& e) {
69895       {
69896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69897       };
69898     } catch (std::exception& e) {
69899       {
69900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69901       };
69902     } catch (Dali::DaliException e) {
69903       {
69904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69905       };
69906     } catch (...) {
69907       {
69908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69909       };
69910     }
69911   }
69912
69913   jresult = (void *)result;
69914   return jresult;
69915 }
69916
69917
69918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69919   void * jresult ;
69920   Dali::Toolkit::Button *arg1 = 0 ;
69921   Dali::Toolkit::Button *result = 0 ;
69922
69923   arg1 = (Dali::Toolkit::Button *)jarg1;
69924   if (!arg1) {
69925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69926     return 0;
69927   }
69928   {
69929     try {
69930       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69931     } catch (std::out_of_range& e) {
69932       {
69933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69934       };
69935     } catch (std::exception& e) {
69936       {
69937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69938       };
69939     } catch (Dali::DaliException e) {
69940       {
69941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69942       };
69943     } catch (...) {
69944       {
69945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69946       };
69947     }
69948   }
69949
69950   jresult = (void *)result;
69951   return jresult;
69952 }
69953
69954
69955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69956   void * jresult ;
69957   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69958   Dali::Toolkit::Button *arg2 = 0 ;
69959   Dali::Toolkit::Button *result = 0 ;
69960
69961   arg1 = (Dali::Toolkit::Button *)jarg1;
69962   arg2 = (Dali::Toolkit::Button *)jarg2;
69963   if (!arg2) {
69964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69965     return 0;
69966   }
69967   {
69968     try {
69969       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69970     } catch (std::out_of_range& e) {
69971       {
69972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69973       };
69974     } catch (std::exception& e) {
69975       {
69976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69977       };
69978     } catch (Dali::DaliException e) {
69979       {
69980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69981       };
69982     } catch (...) {
69983       {
69984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69985       };
69986     }
69987   }
69988
69989   jresult = (void *)result;
69990   return jresult;
69991 }
69992
69993
69994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69995   void * jresult ;
69996   Dali::BaseHandle arg1 ;
69997   Dali::BaseHandle *argp1 ;
69998   Dali::Toolkit::Button result;
69999
70000   argp1 = (Dali::BaseHandle *)jarg1;
70001   if (!argp1) {
70002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70003     return 0;
70004   }
70005   arg1 = *argp1;
70006   {
70007     try {
70008       result = Dali::Toolkit::Button::DownCast(arg1);
70009     } catch (std::out_of_range& e) {
70010       {
70011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70012       };
70013     } catch (std::exception& e) {
70014       {
70015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70016       };
70017     } catch (Dali::DaliException e) {
70018       {
70019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70020       };
70021     } catch (...) {
70022       {
70023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70024       };
70025     }
70026   }
70027
70028   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
70029   return jresult;
70030 }
70031
70032
70033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
70034   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70035
70036   arg1 = (Dali::Toolkit::Button *)jarg1;
70037   {
70038     try {
70039       delete arg1;
70040     } catch (std::out_of_range& e) {
70041       {
70042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70043       };
70044     } catch (std::exception& e) {
70045       {
70046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70047       };
70048     } catch (Dali::DaliException e) {
70049       {
70050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70051       };
70052     } catch (...) {
70053       {
70054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70055       };
70056     }
70057   }
70058
70059 }
70060
70061
70062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
70063   unsigned int jresult ;
70064   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70065   bool result;
70066
70067   arg1 = (Dali::Toolkit::Button *)jarg1;
70068   {
70069     try {
70070       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
70071     } catch (std::out_of_range& e) {
70072       {
70073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70074       };
70075     } catch (std::exception& e) {
70076       {
70077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70078       };
70079     } catch (Dali::DaliException e) {
70080       {
70081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70082       };
70083     } catch (...) {
70084       {
70085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70086       };
70087     }
70088   }
70089
70090   jresult = result;
70091   return jresult;
70092 }
70093
70094
70095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
70096   unsigned int jresult ;
70097   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70098   bool result;
70099
70100   arg1 = (Dali::Toolkit::Button *)jarg1;
70101   {
70102     try {
70103       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
70104     } catch (std::out_of_range& e) {
70105       {
70106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70107       };
70108     } catch (std::exception& e) {
70109       {
70110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70111       };
70112     } catch (Dali::DaliException e) {
70113       {
70114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70115       };
70116     } catch (...) {
70117       {
70118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70119       };
70120     }
70121   }
70122
70123   jresult = result;
70124   return jresult;
70125 }
70126
70127
70128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
70129   float jresult ;
70130   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70131   float result;
70132
70133   arg1 = (Dali::Toolkit::Button *)jarg1;
70134   {
70135     try {
70136       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
70137     } catch (std::out_of_range& e) {
70138       {
70139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70140       };
70141     } catch (std::exception& e) {
70142       {
70143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70144       };
70145     } catch (Dali::DaliException e) {
70146       {
70147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70148       };
70149     } catch (...) {
70150       {
70151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70152       };
70153     }
70154   }
70155
70156   jresult = result;
70157   return jresult;
70158 }
70159
70160
70161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
70162   float jresult ;
70163   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70164   float result;
70165
70166   arg1 = (Dali::Toolkit::Button *)jarg1;
70167   {
70168     try {
70169       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
70170     } catch (std::out_of_range& e) {
70171       {
70172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70173       };
70174     } catch (std::exception& e) {
70175       {
70176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (Dali::DaliException e) {
70179       {
70180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70181       };
70182     } catch (...) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70185       };
70186     }
70187   }
70188
70189   jresult = result;
70190   return jresult;
70191 }
70192
70193
70194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
70195   unsigned int jresult ;
70196   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70197   bool result;
70198
70199   arg1 = (Dali::Toolkit::Button *)jarg1;
70200   {
70201     try {
70202       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
70203     } catch (std::out_of_range& e) {
70204       {
70205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70206       };
70207     } catch (std::exception& e) {
70208       {
70209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (Dali::DaliException e) {
70212       {
70213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70214       };
70215     } catch (...) {
70216       {
70217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70218       };
70219     }
70220   }
70221
70222   jresult = result;
70223   return jresult;
70224 }
70225
70226
70227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
70228   unsigned int jresult ;
70229   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70230   bool result;
70231
70232   arg1 = (Dali::Toolkit::Button *)jarg1;
70233   {
70234     try {
70235       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
70236     } catch (std::out_of_range& e) {
70237       {
70238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70239       };
70240     } catch (std::exception& e) {
70241       {
70242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70243       };
70244     } catch (Dali::DaliException e) {
70245       {
70246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70247       };
70248     } catch (...) {
70249       {
70250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70251       };
70252     }
70253   }
70254
70255   jresult = result;
70256   return jresult;
70257 }
70258
70259
70260 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
70261   float jresult ;
70262   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70263   float result;
70264
70265   arg1 = (Dali::Toolkit::Button *)jarg1;
70266   {
70267     try {
70268       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
70269     } catch (std::out_of_range& e) {
70270       {
70271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70272       };
70273     } catch (std::exception& e) {
70274       {
70275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (Dali::DaliException e) {
70278       {
70279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70280       };
70281     } catch (...) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70284       };
70285     }
70286   }
70287
70288   jresult = result;
70289   return jresult;
70290 }
70291
70292
70293 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
70294   char * jresult ;
70295   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70296   std::string result;
70297
70298   arg1 = (Dali::Toolkit::Button *)jarg1;
70299   {
70300     try {
70301       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
70302     } catch (std::out_of_range& e) {
70303       {
70304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70305       };
70306     } catch (std::exception& e) {
70307       {
70308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (Dali::DaliException e) {
70311       {
70312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70313       };
70314     } catch (...) {
70315       {
70316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70317       };
70318     }
70319   }
70320
70321   jresult = SWIG_csharp_string_callback((&result)->c_str());
70322   return jresult;
70323 }
70324
70325
70326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
70327   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70328   Dali::Actor arg2 ;
70329   Dali::Actor *argp2 ;
70330
70331   arg1 = (Dali::Toolkit::Button *)jarg1;
70332   argp2 = (Dali::Actor *)jarg2;
70333   if (!argp2) {
70334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70335     return ;
70336   }
70337   arg2 = *argp2;
70338   {
70339     try {
70340       (arg1)->SetLabel(arg2);
70341     } catch (std::out_of_range& e) {
70342       {
70343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70344       };
70345     } catch (std::exception& e) {
70346       {
70347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70348       };
70349     } catch (Dali::DaliException e) {
70350       {
70351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70352       };
70353     } catch (...) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70356       };
70357     }
70358   }
70359
70360 }
70361
70362
70363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
70364   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70365   Dali::Image arg2 ;
70366   Dali::Image *argp2 ;
70367
70368   arg1 = (Dali::Toolkit::Button *)jarg1;
70369   argp2 = (Dali::Image *)jarg2;
70370   if (!argp2) {
70371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70372     return ;
70373   }
70374   arg2 = *argp2;
70375   {
70376     try {
70377       (arg1)->SetButtonImage(arg2);
70378     } catch (std::out_of_range& e) {
70379       {
70380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70381       };
70382     } catch (std::exception& e) {
70383       {
70384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70385       };
70386     } catch (Dali::DaliException e) {
70387       {
70388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70389       };
70390     } catch (...) {
70391       {
70392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70393       };
70394     }
70395   }
70396
70397 }
70398
70399
70400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
70401   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70402   Dali::Image arg2 ;
70403   Dali::Image *argp2 ;
70404
70405   arg1 = (Dali::Toolkit::Button *)jarg1;
70406   argp2 = (Dali::Image *)jarg2;
70407   if (!argp2) {
70408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70409     return ;
70410   }
70411   arg2 = *argp2;
70412   {
70413     try {
70414       (arg1)->SetSelectedImage(arg2);
70415     } catch (std::out_of_range& e) {
70416       {
70417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70418       };
70419     } catch (std::exception& e) {
70420       {
70421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70422       };
70423     } catch (Dali::DaliException e) {
70424       {
70425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70426       };
70427     } catch (...) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70430       };
70431     }
70432   }
70433
70434 }
70435
70436
70437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
70438   void * jresult ;
70439   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70440   Dali::Actor result;
70441
70442   arg1 = (Dali::Toolkit::Button *)jarg1;
70443   {
70444     try {
70445       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
70446     } catch (std::out_of_range& e) {
70447       {
70448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70449       };
70450     } catch (std::exception& e) {
70451       {
70452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70453       };
70454     } catch (Dali::DaliException e) {
70455       {
70456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70457       };
70458     } catch (...) {
70459       {
70460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70461       };
70462     }
70463   }
70464
70465   jresult = new Dali::Actor((const Dali::Actor &)result);
70466   return jresult;
70467 }
70468
70469
70470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
70471   void * jresult ;
70472   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70473   Dali::Actor result;
70474
70475   arg1 = (Dali::Toolkit::Button *)jarg1;
70476   {
70477     try {
70478       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
70479     } catch (std::out_of_range& e) {
70480       {
70481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70482       };
70483     } catch (std::exception& e) {
70484       {
70485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (Dali::DaliException e) {
70488       {
70489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70490       };
70491     } catch (...) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70494       };
70495     }
70496   }
70497
70498   jresult = new Dali::Actor((const Dali::Actor &)result);
70499   return jresult;
70500 }
70501
70502
70503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
70504   void * jresult ;
70505   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70506   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70507
70508   arg1 = (Dali::Toolkit::Button *)jarg1;
70509   {
70510     try {
70511       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
70512     } catch (std::out_of_range& e) {
70513       {
70514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70515       };
70516     } catch (std::exception& e) {
70517       {
70518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70519       };
70520     } catch (Dali::DaliException e) {
70521       {
70522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70523       };
70524     } catch (...) {
70525       {
70526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70527       };
70528     }
70529   }
70530
70531   jresult = (void *)result;
70532   return jresult;
70533 }
70534
70535
70536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
70537   void * jresult ;
70538   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70539   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70540
70541   arg1 = (Dali::Toolkit::Button *)jarg1;
70542   {
70543     try {
70544       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
70545     } catch (std::out_of_range& e) {
70546       {
70547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70548       };
70549     } catch (std::exception& e) {
70550       {
70551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70552       };
70553     } catch (Dali::DaliException e) {
70554       {
70555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70556       };
70557     } catch (...) {
70558       {
70559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70560       };
70561     }
70562   }
70563
70564   jresult = (void *)result;
70565   return jresult;
70566 }
70567
70568
70569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
70570   void * jresult ;
70571   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70572   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70573
70574   arg1 = (Dali::Toolkit::Button *)jarg1;
70575   {
70576     try {
70577       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
70578     } catch (std::out_of_range& e) {
70579       {
70580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70581       };
70582     } catch (std::exception& e) {
70583       {
70584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70585       };
70586     } catch (Dali::DaliException e) {
70587       {
70588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70589       };
70590     } catch (...) {
70591       {
70592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70593       };
70594     }
70595   }
70596
70597   jresult = (void *)result;
70598   return jresult;
70599 }
70600
70601
70602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
70603   void * jresult ;
70604   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
70605   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
70606
70607   arg1 = (Dali::Toolkit::Button *)jarg1;
70608   {
70609     try {
70610       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
70611     } catch (std::out_of_range& e) {
70612       {
70613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70614       };
70615     } catch (std::exception& e) {
70616       {
70617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70618       };
70619     } catch (Dali::DaliException e) {
70620       {
70621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70622       };
70623     } catch (...) {
70624       {
70625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70626       };
70627     }
70628   }
70629
70630   jresult = (void *)result;
70631   return jresult;
70632 }
70633
70634
70635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
70636   void * jresult ;
70637   Dali::Toolkit::CheckBoxButton *result = 0 ;
70638
70639   {
70640     try {
70641       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
70642     } catch (std::out_of_range& e) {
70643       {
70644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70645       };
70646     } catch (std::exception& e) {
70647       {
70648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70649       };
70650     } catch (Dali::DaliException e) {
70651       {
70652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70653       };
70654     } catch (...) {
70655       {
70656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70657       };
70658     }
70659   }
70660
70661   jresult = (void *)result;
70662   return jresult;
70663 }
70664
70665
70666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
70667   void * jresult ;
70668   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
70669   Dali::Toolkit::CheckBoxButton *result = 0 ;
70670
70671   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70672   if (!arg1) {
70673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70674     return 0;
70675   }
70676   {
70677     try {
70678       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
70679     } catch (std::out_of_range& e) {
70680       {
70681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70682       };
70683     } catch (std::exception& e) {
70684       {
70685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70686       };
70687     } catch (Dali::DaliException e) {
70688       {
70689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70690       };
70691     } catch (...) {
70692       {
70693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70694       };
70695     }
70696   }
70697
70698   jresult = (void *)result;
70699   return jresult;
70700 }
70701
70702
70703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
70704   void * jresult ;
70705   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70706   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
70707   Dali::Toolkit::CheckBoxButton *result = 0 ;
70708
70709   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70710   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
70711   if (!arg2) {
70712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
70713     return 0;
70714   }
70715   {
70716     try {
70717       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
70718     } catch (std::out_of_range& e) {
70719       {
70720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70721       };
70722     } catch (std::exception& e) {
70723       {
70724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70725       };
70726     } catch (Dali::DaliException e) {
70727       {
70728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70729       };
70730     } catch (...) {
70731       {
70732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70733       };
70734     }
70735   }
70736
70737   jresult = (void *)result;
70738   return jresult;
70739 }
70740
70741
70742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
70743   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
70744
70745   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
70746   {
70747     try {
70748       delete arg1;
70749     } catch (std::out_of_range& e) {
70750       {
70751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70752       };
70753     } catch (std::exception& e) {
70754       {
70755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70756       };
70757     } catch (Dali::DaliException e) {
70758       {
70759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70760       };
70761     } catch (...) {
70762       {
70763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70764       };
70765     }
70766   }
70767
70768 }
70769
70770
70771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70772   void * jresult ;
70773   Dali::Toolkit::CheckBoxButton result;
70774
70775   {
70776     try {
70777       result = Dali::Toolkit::CheckBoxButton::New();
70778     } catch (std::out_of_range& e) {
70779       {
70780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70781       };
70782     } catch (std::exception& e) {
70783       {
70784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70785       };
70786     } catch (Dali::DaliException e) {
70787       {
70788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70789       };
70790     } catch (...) {
70791       {
70792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70793       };
70794     }
70795   }
70796
70797   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70798   return jresult;
70799 }
70800
70801
70802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70803   void * jresult ;
70804   Dali::BaseHandle arg1 ;
70805   Dali::BaseHandle *argp1 ;
70806   Dali::Toolkit::CheckBoxButton result;
70807
70808   argp1 = (Dali::BaseHandle *)jarg1;
70809   if (!argp1) {
70810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70811     return 0;
70812   }
70813   arg1 = *argp1;
70814   {
70815     try {
70816       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70817     } catch (std::out_of_range& e) {
70818       {
70819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70820       };
70821     } catch (std::exception& e) {
70822       {
70823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70824       };
70825     } catch (Dali::DaliException e) {
70826       {
70827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70828       };
70829     } catch (...) {
70830       {
70831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70832       };
70833     }
70834   }
70835
70836   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70837   return jresult;
70838 }
70839
70840
70841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70842   int jresult ;
70843   int result;
70844
70845   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70846   jresult = (int)result;
70847   return jresult;
70848 }
70849
70850
70851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70852   int jresult ;
70853   int result;
70854
70855   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70856   jresult = (int)result;
70857   return jresult;
70858 }
70859
70860
70861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70862   int jresult ;
70863   int result;
70864
70865   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70866   jresult = (int)result;
70867   return jresult;
70868 }
70869
70870
70871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70872   int jresult ;
70873   int result;
70874
70875   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70876   jresult = (int)result;
70877   return jresult;
70878 }
70879
70880
70881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70882   int jresult ;
70883   int result;
70884
70885   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70886   jresult = (int)result;
70887   return jresult;
70888 }
70889
70890
70891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70892   void * jresult ;
70893   Dali::Toolkit::PushButton::Property *result = 0 ;
70894
70895   {
70896     try {
70897       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70898     } catch (std::out_of_range& e) {
70899       {
70900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70901       };
70902     } catch (std::exception& e) {
70903       {
70904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70905       };
70906     } catch (Dali::DaliException e) {
70907       {
70908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70909       };
70910     } catch (...) {
70911       {
70912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70913       };
70914     }
70915   }
70916
70917   jresult = (void *)result;
70918   return jresult;
70919 }
70920
70921
70922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70923   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70924
70925   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70926   {
70927     try {
70928       delete arg1;
70929     } catch (std::out_of_range& e) {
70930       {
70931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70932       };
70933     } catch (std::exception& e) {
70934       {
70935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70936       };
70937     } catch (Dali::DaliException e) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70940       };
70941     } catch (...) {
70942       {
70943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70944       };
70945     }
70946   }
70947
70948 }
70949
70950
70951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70952   void * jresult ;
70953   Dali::Toolkit::PushButton *result = 0 ;
70954
70955   {
70956     try {
70957       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70958     } catch (std::out_of_range& e) {
70959       {
70960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70961       };
70962     } catch (std::exception& e) {
70963       {
70964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70965       };
70966     } catch (Dali::DaliException e) {
70967       {
70968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70969       };
70970     } catch (...) {
70971       {
70972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70973       };
70974     }
70975   }
70976
70977   jresult = (void *)result;
70978   return jresult;
70979 }
70980
70981
70982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70983   void * jresult ;
70984   Dali::Toolkit::PushButton *arg1 = 0 ;
70985   Dali::Toolkit::PushButton *result = 0 ;
70986
70987   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70988   if (!arg1) {
70989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70990     return 0;
70991   }
70992   {
70993     try {
70994       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (Dali::DaliException e) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71010       };
71011     }
71012   }
71013
71014   jresult = (void *)result;
71015   return jresult;
71016 }
71017
71018
71019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
71020   void * jresult ;
71021   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71022   Dali::Toolkit::PushButton *arg2 = 0 ;
71023   Dali::Toolkit::PushButton *result = 0 ;
71024
71025   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71026   arg2 = (Dali::Toolkit::PushButton *)jarg2;
71027   if (!arg2) {
71028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
71029     return 0;
71030   }
71031   {
71032     try {
71033       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
71034     } catch (std::out_of_range& e) {
71035       {
71036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71037       };
71038     } catch (std::exception& e) {
71039       {
71040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71041       };
71042     } catch (Dali::DaliException e) {
71043       {
71044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71045       };
71046     } catch (...) {
71047       {
71048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71049       };
71050     }
71051   }
71052
71053   jresult = (void *)result;
71054   return jresult;
71055 }
71056
71057
71058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
71059   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71060
71061   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71062   {
71063     try {
71064       delete arg1;
71065     } catch (std::out_of_range& e) {
71066       {
71067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71068       };
71069     } catch (std::exception& e) {
71070       {
71071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71072       };
71073     } catch (Dali::DaliException e) {
71074       {
71075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71076       };
71077     } catch (...) {
71078       {
71079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71080       };
71081     }
71082   }
71083
71084 }
71085
71086
71087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
71088   void * jresult ;
71089   Dali::Toolkit::PushButton result;
71090
71091   {
71092     try {
71093       result = Dali::Toolkit::PushButton::New();
71094     } catch (std::out_of_range& e) {
71095       {
71096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71097       };
71098     } catch (std::exception& e) {
71099       {
71100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71101       };
71102     } catch (Dali::DaliException e) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71105       };
71106     } catch (...) {
71107       {
71108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71109       };
71110     }
71111   }
71112
71113   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71114   return jresult;
71115 }
71116
71117
71118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
71119   void * jresult ;
71120   Dali::BaseHandle arg1 ;
71121   Dali::BaseHandle *argp1 ;
71122   Dali::Toolkit::PushButton result;
71123
71124   argp1 = (Dali::BaseHandle *)jarg1;
71125   if (!argp1) {
71126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71127     return 0;
71128   }
71129   arg1 = *argp1;
71130   {
71131     try {
71132       result = Dali::Toolkit::PushButton::DownCast(arg1);
71133     } catch (std::out_of_range& e) {
71134       {
71135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71136       };
71137     } catch (std::exception& e) {
71138       {
71139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71140       };
71141     } catch (Dali::DaliException e) {
71142       {
71143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71144       };
71145     } catch (...) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71148       };
71149     }
71150   }
71151
71152   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
71153   return jresult;
71154 }
71155
71156
71157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
71158   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71159   Dali::Image arg2 ;
71160   Dali::Image *argp2 ;
71161
71162   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71163   argp2 = (Dali::Image *)jarg2;
71164   if (!argp2) {
71165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71166     return ;
71167   }
71168   arg2 = *argp2;
71169   {
71170     try {
71171       (arg1)->SetButtonImage(arg2);
71172     } catch (std::out_of_range& e) {
71173       {
71174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71175       };
71176     } catch (std::exception& e) {
71177       {
71178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71179       };
71180     } catch (Dali::DaliException e) {
71181       {
71182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71183       };
71184     } catch (...) {
71185       {
71186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71187       };
71188     }
71189   }
71190
71191 }
71192
71193
71194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
71195   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71196   Dali::Actor arg2 ;
71197   Dali::Actor *argp2 ;
71198
71199   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71200   argp2 = (Dali::Actor *)jarg2;
71201   if (!argp2) {
71202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71203     return ;
71204   }
71205   arg2 = *argp2;
71206   {
71207     try {
71208       (arg1)->SetButtonImage(arg2);
71209     } catch (std::out_of_range& e) {
71210       {
71211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71212       };
71213     } catch (std::exception& e) {
71214       {
71215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71216       };
71217     } catch (Dali::DaliException e) {
71218       {
71219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71220       };
71221     } catch (...) {
71222       {
71223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71224       };
71225     }
71226   }
71227
71228 }
71229
71230
71231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
71232   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71233   Dali::Actor arg2 ;
71234   Dali::Actor *argp2 ;
71235
71236   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71237   argp2 = (Dali::Actor *)jarg2;
71238   if (!argp2) {
71239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71240     return ;
71241   }
71242   arg2 = *argp2;
71243   {
71244     try {
71245       (arg1)->SetBackgroundImage(arg2);
71246     } catch (std::out_of_range& e) {
71247       {
71248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71249       };
71250     } catch (std::exception& e) {
71251       {
71252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71253       };
71254     } catch (Dali::DaliException e) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71257       };
71258     } catch (...) {
71259       {
71260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71261       };
71262     }
71263   }
71264
71265 }
71266
71267
71268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
71269   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71270   Dali::Image arg2 ;
71271   Dali::Image *argp2 ;
71272
71273   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71274   argp2 = (Dali::Image *)jarg2;
71275   if (!argp2) {
71276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71277     return ;
71278   }
71279   arg2 = *argp2;
71280   {
71281     try {
71282       (arg1)->SetSelectedImage(arg2);
71283     } catch (std::out_of_range& e) {
71284       {
71285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71286       };
71287     } catch (std::exception& e) {
71288       {
71289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71290       };
71291     } catch (Dali::DaliException e) {
71292       {
71293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71294       };
71295     } catch (...) {
71296       {
71297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71298       };
71299     }
71300   }
71301
71302 }
71303
71304
71305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
71306   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71307   Dali::Actor arg2 ;
71308   Dali::Actor *argp2 ;
71309
71310   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71311   argp2 = (Dali::Actor *)jarg2;
71312   if (!argp2) {
71313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71314     return ;
71315   }
71316   arg2 = *argp2;
71317   {
71318     try {
71319       (arg1)->SetSelectedImage(arg2);
71320     } catch (std::out_of_range& e) {
71321       {
71322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71323       };
71324     } catch (std::exception& e) {
71325       {
71326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71327       };
71328     } catch (Dali::DaliException e) {
71329       {
71330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71331       };
71332     } catch (...) {
71333       {
71334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71335       };
71336     }
71337   }
71338
71339 }
71340
71341
71342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
71343   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71344   Dali::Actor arg2 ;
71345   Dali::Actor *argp2 ;
71346
71347   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71348   argp2 = (Dali::Actor *)jarg2;
71349   if (!argp2) {
71350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71351     return ;
71352   }
71353   arg2 = *argp2;
71354   {
71355     try {
71356       (arg1)->SetSelectedBackgroundImage(arg2);
71357     } catch (std::out_of_range& e) {
71358       {
71359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71360       };
71361     } catch (std::exception& e) {
71362       {
71363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71364       };
71365     } catch (Dali::DaliException e) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71368       };
71369     } catch (...) {
71370       {
71371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71372       };
71373     }
71374   }
71375
71376 }
71377
71378
71379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
71380   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71381   Dali::Actor arg2 ;
71382   Dali::Actor *argp2 ;
71383
71384   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71385   argp2 = (Dali::Actor *)jarg2;
71386   if (!argp2) {
71387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71388     return ;
71389   }
71390   arg2 = *argp2;
71391   {
71392     try {
71393       (arg1)->SetDisabledBackgroundImage(arg2);
71394     } catch (std::out_of_range& e) {
71395       {
71396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71397       };
71398     } catch (std::exception& e) {
71399       {
71400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71401       };
71402     } catch (Dali::DaliException e) {
71403       {
71404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71405       };
71406     } catch (...) {
71407       {
71408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71409       };
71410     }
71411   }
71412
71413 }
71414
71415
71416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
71417   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71418   Dali::Actor arg2 ;
71419   Dali::Actor *argp2 ;
71420
71421   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71422   argp2 = (Dali::Actor *)jarg2;
71423   if (!argp2) {
71424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71425     return ;
71426   }
71427   arg2 = *argp2;
71428   {
71429     try {
71430       (arg1)->SetDisabledImage(arg2);
71431     } catch (std::out_of_range& e) {
71432       {
71433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71434       };
71435     } catch (std::exception& e) {
71436       {
71437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71438       };
71439     } catch (Dali::DaliException e) {
71440       {
71441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71442       };
71443     } catch (...) {
71444       {
71445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71446       };
71447     }
71448   }
71449
71450 }
71451
71452
71453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
71454   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
71455   Dali::Actor arg2 ;
71456   Dali::Actor *argp2 ;
71457
71458   arg1 = (Dali::Toolkit::PushButton *)jarg1;
71459   argp2 = (Dali::Actor *)jarg2;
71460   if (!argp2) {
71461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71462     return ;
71463   }
71464   arg2 = *argp2;
71465   {
71466     try {
71467       (arg1)->SetDisabledSelectedImage(arg2);
71468     } catch (std::out_of_range& e) {
71469       {
71470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71471       };
71472     } catch (std::exception& e) {
71473       {
71474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71475       };
71476     } catch (Dali::DaliException e) {
71477       {
71478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71479       };
71480     } catch (...) {
71481       {
71482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71483       };
71484     }
71485   }
71486
71487 }
71488
71489
71490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
71491   void * jresult ;
71492   Dali::Toolkit::RadioButton *result = 0 ;
71493
71494   {
71495     try {
71496       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
71497     } catch (std::out_of_range& e) {
71498       {
71499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71500       };
71501     } catch (std::exception& e) {
71502       {
71503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71504       };
71505     } catch (Dali::DaliException e) {
71506       {
71507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71508       };
71509     } catch (...) {
71510       {
71511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71512       };
71513     }
71514   }
71515
71516   jresult = (void *)result;
71517   return jresult;
71518 }
71519
71520
71521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
71522   void * jresult ;
71523   Dali::Toolkit::RadioButton *arg1 = 0 ;
71524   Dali::Toolkit::RadioButton *result = 0 ;
71525
71526   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71527   if (!arg1) {
71528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71529     return 0;
71530   }
71531   {
71532     try {
71533       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
71534     } catch (std::out_of_range& e) {
71535       {
71536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71537       };
71538     } catch (std::exception& e) {
71539       {
71540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71541       };
71542     } catch (Dali::DaliException e) {
71543       {
71544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71545       };
71546     } catch (...) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71549       };
71550     }
71551   }
71552
71553   jresult = (void *)result;
71554   return jresult;
71555 }
71556
71557
71558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
71559   void * jresult ;
71560   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71561   Dali::Toolkit::RadioButton *arg2 = 0 ;
71562   Dali::Toolkit::RadioButton *result = 0 ;
71563
71564   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71565   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
71566   if (!arg2) {
71567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
71568     return 0;
71569   }
71570   {
71571     try {
71572       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
71573     } catch (std::out_of_range& e) {
71574       {
71575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71576       };
71577     } catch (std::exception& e) {
71578       {
71579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71580       };
71581     } catch (Dali::DaliException e) {
71582       {
71583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71584       };
71585     } catch (...) {
71586       {
71587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71588       };
71589     }
71590   }
71591
71592   jresult = (void *)result;
71593   return jresult;
71594 }
71595
71596
71597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
71598   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
71599
71600   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
71601   {
71602     try {
71603       delete arg1;
71604     } catch (std::out_of_range& e) {
71605       {
71606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71607       };
71608     } catch (std::exception& e) {
71609       {
71610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71611       };
71612     } catch (Dali::DaliException e) {
71613       {
71614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71615       };
71616     } catch (...) {
71617       {
71618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71619       };
71620     }
71621   }
71622
71623 }
71624
71625
71626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
71627   void * jresult ;
71628   Dali::Toolkit::RadioButton result;
71629
71630   {
71631     try {
71632       result = Dali::Toolkit::RadioButton::New();
71633     } catch (std::out_of_range& e) {
71634       {
71635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (std::exception& e) {
71638       {
71639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71640       };
71641     } catch (Dali::DaliException e) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71644       };
71645     } catch (...) {
71646       {
71647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71648       };
71649     }
71650   }
71651
71652   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71653   return jresult;
71654 }
71655
71656
71657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
71658   void * jresult ;
71659   std::string *arg1 = 0 ;
71660   Dali::Toolkit::RadioButton result;
71661
71662   if (!jarg1) {
71663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71664     return 0;
71665   }
71666   std::string arg1_str(jarg1);
71667   arg1 = &arg1_str;
71668   {
71669     try {
71670       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
71671     } catch (std::out_of_range& e) {
71672       {
71673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (std::exception& e) {
71676       {
71677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71678       };
71679     } catch (Dali::DaliException e) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71682       };
71683     } catch (...) {
71684       {
71685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71686       };
71687     }
71688   }
71689
71690   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71691
71692   //argout typemap for const std::string&
71693
71694   return jresult;
71695 }
71696
71697
71698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
71699   void * jresult ;
71700   Dali::BaseHandle arg1 ;
71701   Dali::BaseHandle *argp1 ;
71702   Dali::Toolkit::RadioButton result;
71703
71704   argp1 = (Dali::BaseHandle *)jarg1;
71705   if (!argp1) {
71706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71707     return 0;
71708   }
71709   arg1 = *argp1;
71710   {
71711     try {
71712       result = Dali::Toolkit::RadioButton::DownCast(arg1);
71713     } catch (std::out_of_range& e) {
71714       {
71715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71716       };
71717     } catch (std::exception& e) {
71718       {
71719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (Dali::DaliException e) {
71722       {
71723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71724       };
71725     } catch (...) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71728       };
71729     }
71730   }
71731
71732   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
71733   return jresult;
71734 }
71735
71736
71737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
71738   int jresult ;
71739   int result;
71740
71741   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
71742   jresult = (int)result;
71743   return jresult;
71744 }
71745
71746
71747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
71748   int jresult ;
71749   int result;
71750
71751   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71752   jresult = (int)result;
71753   return jresult;
71754 }
71755
71756
71757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71758   int jresult ;
71759   int result;
71760
71761   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71762   jresult = (int)result;
71763   return jresult;
71764 }
71765
71766
71767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71768   int jresult ;
71769   int result;
71770
71771   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71772   jresult = (int)result;
71773   return jresult;
71774 }
71775
71776
71777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71778   int jresult ;
71779   int result;
71780
71781   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71782   jresult = (int)result;
71783   return jresult;
71784 }
71785
71786
71787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71788   int jresult ;
71789   int result;
71790
71791   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71792   jresult = (int)result;
71793   return jresult;
71794 }
71795
71796
71797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71798   void * jresult ;
71799   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71800
71801   {
71802     try {
71803       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71804     } catch (std::out_of_range& e) {
71805       {
71806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71807       };
71808     } catch (std::exception& e) {
71809       {
71810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71811       };
71812     } catch (Dali::DaliException e) {
71813       {
71814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71815       };
71816     } catch (...) {
71817       {
71818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71819       };
71820     }
71821   }
71822
71823   jresult = (void *)result;
71824   return jresult;
71825 }
71826
71827
71828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71829   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71830
71831   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71832   {
71833     try {
71834       delete arg1;
71835     } catch (std::out_of_range& e) {
71836       {
71837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71838       };
71839     } catch (std::exception& e) {
71840       {
71841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71842       };
71843     } catch (Dali::DaliException e) {
71844       {
71845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71846       };
71847     } catch (...) {
71848       {
71849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71850       };
71851     }
71852   }
71853
71854 }
71855
71856
71857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71858   int jresult ;
71859   int result;
71860
71861   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71862   jresult = (int)result;
71863   return jresult;
71864 }
71865
71866
71867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71868   int jresult ;
71869   int result;
71870
71871   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71872   jresult = (int)result;
71873   return jresult;
71874 }
71875
71876
71877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71878   int jresult ;
71879   int result;
71880
71881   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71882   jresult = (int)result;
71883   return jresult;
71884 }
71885
71886
71887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71888   void * jresult ;
71889   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71890
71891   {
71892     try {
71893       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71894     } catch (std::out_of_range& e) {
71895       {
71896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71897       };
71898     } catch (std::exception& e) {
71899       {
71900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71901       };
71902     } catch (Dali::DaliException e) {
71903       {
71904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71905       };
71906     } catch (...) {
71907       {
71908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71909       };
71910     }
71911   }
71912
71913   jresult = (void *)result;
71914   return jresult;
71915 }
71916
71917
71918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71919   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71920
71921   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71922   {
71923     try {
71924       delete arg1;
71925     } catch (std::out_of_range& e) {
71926       {
71927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71928       };
71929     } catch (std::exception& e) {
71930       {
71931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71932       };
71933     } catch (Dali::DaliException e) {
71934       {
71935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71936       };
71937     } catch (...) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71940       };
71941     }
71942   }
71943
71944 }
71945
71946
71947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71948   void * jresult ;
71949   Dali::Toolkit::FlexContainer *result = 0 ;
71950
71951   {
71952     try {
71953       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71954     } catch (std::out_of_range& e) {
71955       {
71956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71957       };
71958     } catch (std::exception& e) {
71959       {
71960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71961       };
71962     } catch (Dali::DaliException e) {
71963       {
71964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71965       };
71966     } catch (...) {
71967       {
71968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71969       };
71970     }
71971   }
71972
71973   jresult = (void *)result;
71974   return jresult;
71975 }
71976
71977
71978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71979   void * jresult ;
71980   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71981   Dali::Toolkit::FlexContainer *result = 0 ;
71982
71983   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71984   if (!arg1) {
71985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71986     return 0;
71987   }
71988   {
71989     try {
71990       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71991     } catch (std::out_of_range& e) {
71992       {
71993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71994       };
71995     } catch (std::exception& e) {
71996       {
71997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71998       };
71999     } catch (Dali::DaliException e) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72002       };
72003     } catch (...) {
72004       {
72005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72006       };
72007     }
72008   }
72009
72010   jresult = (void *)result;
72011   return jresult;
72012 }
72013
72014
72015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
72016   void * jresult ;
72017   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72018   Dali::Toolkit::FlexContainer *arg2 = 0 ;
72019   Dali::Toolkit::FlexContainer *result = 0 ;
72020
72021   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72022   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
72023   if (!arg2) {
72024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
72025     return 0;
72026   }
72027   {
72028     try {
72029       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
72030     } catch (std::out_of_range& e) {
72031       {
72032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72033       };
72034     } catch (std::exception& e) {
72035       {
72036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72037       };
72038     } catch (Dali::DaliException e) {
72039       {
72040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72041       };
72042     } catch (...) {
72043       {
72044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72045       };
72046     }
72047   }
72048
72049   jresult = (void *)result;
72050   return jresult;
72051 }
72052
72053
72054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
72055   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
72056
72057   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
72058   {
72059     try {
72060       delete arg1;
72061     } catch (std::out_of_range& e) {
72062       {
72063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72064       };
72065     } catch (std::exception& e) {
72066       {
72067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72068       };
72069     } catch (Dali::DaliException e) {
72070       {
72071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72072       };
72073     } catch (...) {
72074       {
72075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72076       };
72077     }
72078   }
72079
72080 }
72081
72082
72083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
72084   void * jresult ;
72085   Dali::Toolkit::FlexContainer result;
72086
72087   {
72088     try {
72089       result = Dali::Toolkit::FlexContainer::New();
72090     } catch (std::out_of_range& e) {
72091       {
72092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72093       };
72094     } catch (std::exception& e) {
72095       {
72096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72097       };
72098     } catch (Dali::DaliException e) {
72099       {
72100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72101       };
72102     } catch (...) {
72103       {
72104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72105       };
72106     }
72107   }
72108
72109   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72110   return jresult;
72111 }
72112
72113
72114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
72115   void * jresult ;
72116   Dali::BaseHandle arg1 ;
72117   Dali::BaseHandle *argp1 ;
72118   Dali::Toolkit::FlexContainer result;
72119
72120   argp1 = (Dali::BaseHandle *)jarg1;
72121   if (!argp1) {
72122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72123     return 0;
72124   }
72125   arg1 = *argp1;
72126   {
72127     try {
72128       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
72129     } catch (std::out_of_range& e) {
72130       {
72131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72132       };
72133     } catch (std::exception& e) {
72134       {
72135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72136       };
72137     } catch (Dali::DaliException e) {
72138       {
72139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72140       };
72141     } catch (...) {
72142       {
72143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72144       };
72145     }
72146   }
72147
72148   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
72149   return jresult;
72150 }
72151
72152
72153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
72154   int jresult ;
72155   int result;
72156
72157   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
72158   jresult = (int)result;
72159   return jresult;
72160 }
72161
72162
72163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
72164   int jresult ;
72165   int result;
72166
72167   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
72168   jresult = (int)result;
72169   return jresult;
72170 }
72171
72172
72173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
72174   int jresult ;
72175   int result;
72176
72177   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
72178   jresult = (int)result;
72179   return jresult;
72180 }
72181
72182
72183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
72184   int jresult ;
72185   int result;
72186
72187   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
72188   jresult = (int)result;
72189   return jresult;
72190 }
72191
72192
72193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
72194   void * jresult ;
72195   Dali::Toolkit::ImageView::Property *result = 0 ;
72196
72197   {
72198     try {
72199       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
72200     } catch (std::out_of_range& e) {
72201       {
72202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72203       };
72204     } catch (std::exception& e) {
72205       {
72206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72207       };
72208     } catch (Dali::DaliException e) {
72209       {
72210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72211       };
72212     } catch (...) {
72213       {
72214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72215       };
72216     }
72217   }
72218
72219   jresult = (void *)result;
72220   return jresult;
72221 }
72222
72223
72224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
72225   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
72226
72227   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
72228   {
72229     try {
72230       delete arg1;
72231     } catch (std::out_of_range& e) {
72232       {
72233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72234       };
72235     } catch (std::exception& e) {
72236       {
72237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72238       };
72239     } catch (Dali::DaliException e) {
72240       {
72241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72242       };
72243     } catch (...) {
72244       {
72245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72246       };
72247     }
72248   }
72249
72250 }
72251
72252
72253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
72254   void * jresult ;
72255   Dali::Toolkit::ImageView *result = 0 ;
72256
72257   {
72258     try {
72259       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
72260     } catch (std::out_of_range& e) {
72261       {
72262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72263       };
72264     } catch (std::exception& e) {
72265       {
72266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72267       };
72268     } catch (Dali::DaliException e) {
72269       {
72270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72271       };
72272     } catch (...) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72275       };
72276     }
72277   }
72278
72279   jresult = (void *)result;
72280   return jresult;
72281 }
72282
72283
72284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
72285   void * jresult ;
72286   Dali::Toolkit::ImageView result;
72287
72288   {
72289     try {
72290       result = Dali::Toolkit::ImageView::New();
72291     } catch (std::out_of_range& e) {
72292       {
72293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72294       };
72295     } catch (std::exception& e) {
72296       {
72297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72298       };
72299     } catch (Dali::DaliException e) {
72300       {
72301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72302       };
72303     } catch (...) {
72304       {
72305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72306       };
72307     }
72308   }
72309
72310   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72311   return jresult;
72312 }
72313
72314
72315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
72316   void * jresult ;
72317   Dali::Image arg1 ;
72318   Dali::Image *argp1 ;
72319   Dali::Toolkit::ImageView result;
72320
72321   argp1 = (Dali::Image *)jarg1;
72322   if (!argp1) {
72323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72324     return 0;
72325   }
72326   arg1 = *argp1;
72327   {
72328     try {
72329       result = Dali::Toolkit::ImageView::New(arg1);
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72345       };
72346     }
72347   }
72348
72349   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72350   return jresult;
72351 }
72352
72353
72354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
72355   void * jresult ;
72356   std::string *arg1 = 0 ;
72357   Dali::Toolkit::ImageView result;
72358
72359   if (!jarg1) {
72360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72361     return 0;
72362   }
72363   std::string arg1_str(jarg1);
72364   arg1 = &arg1_str;
72365   {
72366     try {
72367       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
72368     } catch (std::out_of_range& e) {
72369       {
72370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72371       };
72372     } catch (std::exception& e) {
72373       {
72374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72375       };
72376     } catch (Dali::DaliException e) {
72377       {
72378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72379       };
72380     } catch (...) {
72381       {
72382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72383       };
72384     }
72385   }
72386
72387   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72388
72389   //argout typemap for const std::string&
72390
72391   return jresult;
72392 }
72393
72394
72395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
72396   void * jresult ;
72397   std::string *arg1 = 0 ;
72398   Dali::ImageDimensions arg2 ;
72399   Dali::ImageDimensions *argp2 ;
72400   Dali::Toolkit::ImageView result;
72401
72402   if (!jarg1) {
72403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72404     return 0;
72405   }
72406   std::string arg1_str(jarg1);
72407   arg1 = &arg1_str;
72408   argp2 = (Dali::ImageDimensions *)jarg2;
72409   if (!argp2) {
72410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72411     return 0;
72412   }
72413   arg2 = *argp2;
72414   {
72415     try {
72416       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
72417     } catch (std::out_of_range& e) {
72418       {
72419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72420       };
72421     } catch (std::exception& e) {
72422       {
72423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72424       };
72425     } catch (Dali::DaliException e) {
72426       {
72427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72428       };
72429     } catch (...) {
72430       {
72431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72432       };
72433     }
72434   }
72435
72436   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72437
72438   //argout typemap for const std::string&
72439
72440   return jresult;
72441 }
72442
72443
72444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
72445   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72446
72447   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72448   {
72449     try {
72450       delete arg1;
72451     } catch (std::out_of_range& e) {
72452       {
72453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72454       };
72455     } catch (std::exception& e) {
72456       {
72457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72458       };
72459     } catch (Dali::DaliException e) {
72460       {
72461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72462       };
72463     } catch (...) {
72464       {
72465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72466       };
72467     }
72468   }
72469
72470 }
72471
72472
72473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
72474   void * jresult ;
72475   Dali::Toolkit::ImageView *arg1 = 0 ;
72476   Dali::Toolkit::ImageView *result = 0 ;
72477
72478   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72479   if (!arg1) {
72480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72481     return 0;
72482   }
72483   {
72484     try {
72485       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
72486     } catch (std::out_of_range& e) {
72487       {
72488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72489       };
72490     } catch (std::exception& e) {
72491       {
72492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72493       };
72494     } catch (Dali::DaliException e) {
72495       {
72496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72497       };
72498     } catch (...) {
72499       {
72500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72501       };
72502     }
72503   }
72504
72505   jresult = (void *)result;
72506   return jresult;
72507 }
72508
72509
72510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
72511   void * jresult ;
72512   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72513   Dali::Toolkit::ImageView *arg2 = 0 ;
72514   Dali::Toolkit::ImageView *result = 0 ;
72515
72516   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72517   arg2 = (Dali::Toolkit::ImageView *)jarg2;
72518   if (!arg2) {
72519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
72520     return 0;
72521   }
72522   {
72523     try {
72524       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
72525     } catch (std::out_of_range& e) {
72526       {
72527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72528       };
72529     } catch (std::exception& e) {
72530       {
72531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72532       };
72533     } catch (Dali::DaliException e) {
72534       {
72535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72536       };
72537     } catch (...) {
72538       {
72539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72540       };
72541     }
72542   }
72543
72544   jresult = (void *)result;
72545   return jresult;
72546 }
72547
72548
72549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
72550   void * jresult ;
72551   Dali::BaseHandle arg1 ;
72552   Dali::BaseHandle *argp1 ;
72553   Dali::Toolkit::ImageView result;
72554
72555   argp1 = (Dali::BaseHandle *)jarg1;
72556   if (!argp1) {
72557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72558     return 0;
72559   }
72560   arg1 = *argp1;
72561   {
72562     try {
72563       result = Dali::Toolkit::ImageView::DownCast(arg1);
72564     } catch (std::out_of_range& e) {
72565       {
72566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72567       };
72568     } catch (std::exception& e) {
72569       {
72570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72571       };
72572     } catch (Dali::DaliException e) {
72573       {
72574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72575       };
72576     } catch (...) {
72577       {
72578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72579       };
72580     }
72581   }
72582
72583   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
72584   return jresult;
72585 }
72586
72587
72588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
72589   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72590   Dali::Image arg2 ;
72591   Dali::Image *argp2 ;
72592
72593   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72594   argp2 = (Dali::Image *)jarg2;
72595   if (!argp2) {
72596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
72597     return ;
72598   }
72599   arg2 = *argp2;
72600   {
72601     try {
72602       (arg1)->SetImage(arg2);
72603     } catch (std::out_of_range& e) {
72604       {
72605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72606       };
72607     } catch (std::exception& e) {
72608       {
72609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72610       };
72611     } catch (Dali::DaliException e) {
72612       {
72613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72614       };
72615     } catch (...) {
72616       {
72617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72618       };
72619     }
72620   }
72621
72622 }
72623
72624
72625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
72626   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72627   std::string *arg2 = 0 ;
72628
72629   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72630   if (!jarg2) {
72631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72632     return ;
72633   }
72634   std::string arg2_str(jarg2);
72635   arg2 = &arg2_str;
72636   {
72637     try {
72638       (arg1)->SetImage((std::string const &)*arg2);
72639     } catch (std::out_of_range& e) {
72640       {
72641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72642       };
72643     } catch (std::exception& e) {
72644       {
72645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72646       };
72647     } catch (Dali::DaliException e) {
72648       {
72649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72650       };
72651     } catch (...) {
72652       {
72653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72654       };
72655     }
72656   }
72657
72658
72659   //argout typemap for const std::string&
72660
72661 }
72662
72663
72664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
72665   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72666   std::string *arg2 = 0 ;
72667   Dali::ImageDimensions arg3 ;
72668   Dali::ImageDimensions *argp3 ;
72669
72670   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72671   if (!jarg2) {
72672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72673     return ;
72674   }
72675   std::string arg2_str(jarg2);
72676   arg2 = &arg2_str;
72677   argp3 = (Dali::ImageDimensions *)jarg3;
72678   if (!argp3) {
72679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
72680     return ;
72681   }
72682   arg3 = *argp3;
72683   {
72684     try {
72685       (arg1)->SetImage((std::string const &)*arg2,arg3);
72686     } catch (std::out_of_range& e) {
72687       {
72688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72689       };
72690     } catch (std::exception& e) {
72691       {
72692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72693       };
72694     } catch (Dali::DaliException e) {
72695       {
72696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72697       };
72698     } catch (...) {
72699       {
72700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72701       };
72702     }
72703   }
72704
72705
72706   //argout typemap for const std::string&
72707
72708 }
72709
72710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
72711   void * jresult ;
72712   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
72713   Dali::Image result;
72714
72715   arg1 = (Dali::Toolkit::ImageView *)jarg1;
72716   {
72717     try {
72718       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
72719     } catch (std::out_of_range& e) {
72720       {
72721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72722       };
72723     } catch (std::exception& e) {
72724       {
72725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72726       };
72727     } catch (Dali::DaliException e) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72730       };
72731     } catch (...) {
72732       {
72733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72734       };
72735     }
72736   }
72737
72738   jresult = new Dali::Image((const Dali::Image &)result);
72739   return jresult;
72740 }
72741
72742
72743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
72744   int jresult ;
72745   int result;
72746
72747   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
72748   jresult = (int)result;
72749   return jresult;
72750 }
72751
72752
72753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72754   int jresult ;
72755   int result;
72756
72757   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72758   jresult = (int)result;
72759   return jresult;
72760 }
72761
72762
72763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72764   int jresult ;
72765   int result;
72766
72767   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72768   jresult = (int)result;
72769   return jresult;
72770 }
72771
72772
72773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72774   int jresult ;
72775   int result;
72776
72777   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72778   jresult = (int)result;
72779   return jresult;
72780 }
72781
72782
72783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72784   int jresult ;
72785   int result;
72786
72787   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72788   jresult = (int)result;
72789   return jresult;
72790 }
72791
72792
72793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72794   int jresult ;
72795   int result;
72796
72797   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72798   jresult = (int)result;
72799   return jresult;
72800 }
72801
72802
72803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72804   int jresult ;
72805   int result;
72806
72807   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72808   jresult = (int)result;
72809   return jresult;
72810 }
72811
72812
72813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72814   int jresult ;
72815   int result;
72816
72817   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72818   jresult = (int)result;
72819   return jresult;
72820 }
72821
72822
72823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72824   void * jresult ;
72825   Dali::Toolkit::Model3dView::Property *result = 0 ;
72826
72827   {
72828     try {
72829       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72830     } catch (std::out_of_range& e) {
72831       {
72832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72833       };
72834     } catch (std::exception& e) {
72835       {
72836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72837       };
72838     } catch (Dali::DaliException e) {
72839       {
72840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72841       };
72842     } catch (...) {
72843       {
72844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72845       };
72846     }
72847   }
72848
72849   jresult = (void *)result;
72850   return jresult;
72851 }
72852
72853
72854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72855   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72856
72857   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72858   {
72859     try {
72860       delete arg1;
72861     } catch (std::out_of_range& e) {
72862       {
72863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72864       };
72865     } catch (std::exception& e) {
72866       {
72867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72868       };
72869     } catch (Dali::DaliException e) {
72870       {
72871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72872       };
72873     } catch (...) {
72874       {
72875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72876       };
72877     }
72878   }
72879
72880 }
72881
72882
72883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72884   void * jresult ;
72885   Dali::Toolkit::Model3dView result;
72886
72887   {
72888     try {
72889       result = Dali::Toolkit::Model3dView::New();
72890     } catch (std::out_of_range& e) {
72891       {
72892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72893       };
72894     } catch (std::exception& e) {
72895       {
72896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72897       };
72898     } catch (Dali::DaliException e) {
72899       {
72900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72901       };
72902     } catch (...) {
72903       {
72904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72905       };
72906     }
72907   }
72908
72909   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72910   return jresult;
72911 }
72912
72913
72914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72915   void * jresult ;
72916   std::string *arg1 = 0 ;
72917   std::string *arg2 = 0 ;
72918   std::string *arg3 = 0 ;
72919   Dali::Toolkit::Model3dView result;
72920
72921   if (!jarg1) {
72922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72923     return 0;
72924   }
72925   std::string arg1_str(jarg1);
72926   arg1 = &arg1_str;
72927   if (!jarg2) {
72928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72929     return 0;
72930   }
72931   std::string arg2_str(jarg2);
72932   arg2 = &arg2_str;
72933   if (!jarg3) {
72934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72935     return 0;
72936   }
72937   std::string arg3_str(jarg3);
72938   arg3 = &arg3_str;
72939   {
72940     try {
72941       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72942     } catch (std::out_of_range& e) {
72943       {
72944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72945       };
72946     } catch (std::exception& e) {
72947       {
72948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72949       };
72950     } catch (Dali::DaliException e) {
72951       {
72952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72953       };
72954     } catch (...) {
72955       {
72956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72957       };
72958     }
72959   }
72960
72961   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72962
72963   //argout typemap for const std::string&
72964
72965
72966   //argout typemap for const std::string&
72967
72968
72969   //argout typemap for const std::string&
72970
72971   return jresult;
72972 }
72973
72974
72975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72976   void * jresult ;
72977   Dali::Toolkit::Model3dView *result = 0 ;
72978
72979   {
72980     try {
72981       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72982     } catch (std::out_of_range& e) {
72983       {
72984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72985       };
72986     } catch (std::exception& e) {
72987       {
72988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72989       };
72990     } catch (Dali::DaliException e) {
72991       {
72992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72993       };
72994     } catch (...) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72997       };
72998     }
72999   }
73000
73001   jresult = (void *)result;
73002   return jresult;
73003 }
73004
73005
73006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
73007   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73008
73009   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73010   {
73011     try {
73012       delete arg1;
73013     } catch (std::out_of_range& e) {
73014       {
73015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73016       };
73017     } catch (std::exception& e) {
73018       {
73019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73020       };
73021     } catch (Dali::DaliException e) {
73022       {
73023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73024       };
73025     } catch (...) {
73026       {
73027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73028       };
73029     }
73030   }
73031
73032 }
73033
73034
73035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
73036   void * jresult ;
73037   Dali::Toolkit::Model3dView *arg1 = 0 ;
73038   Dali::Toolkit::Model3dView *result = 0 ;
73039
73040   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73041   if (!arg1) {
73042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73043     return 0;
73044   }
73045   {
73046     try {
73047       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
73048     } catch (std::out_of_range& e) {
73049       {
73050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73051       };
73052     } catch (std::exception& e) {
73053       {
73054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73055       };
73056     } catch (Dali::DaliException e) {
73057       {
73058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73059       };
73060     } catch (...) {
73061       {
73062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73063       };
73064     }
73065   }
73066
73067   jresult = (void *)result;
73068   return jresult;
73069 }
73070
73071
73072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
73073   void * jresult ;
73074   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
73075   Dali::Toolkit::Model3dView *arg2 = 0 ;
73076   Dali::Toolkit::Model3dView *result = 0 ;
73077
73078   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
73079   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
73080   if (!arg2) {
73081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
73082     return 0;
73083   }
73084   {
73085     try {
73086       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
73087     } catch (std::out_of_range& e) {
73088       {
73089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (std::exception& e) {
73092       {
73093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73094       };
73095     } catch (Dali::DaliException e) {
73096       {
73097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73098       };
73099     } catch (...) {
73100       {
73101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73102       };
73103     }
73104   }
73105
73106   jresult = (void *)result;
73107   return jresult;
73108 }
73109
73110
73111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
73112   void * jresult ;
73113   Dali::BaseHandle arg1 ;
73114   Dali::BaseHandle *argp1 ;
73115   Dali::Toolkit::Model3dView result;
73116
73117   argp1 = (Dali::BaseHandle *)jarg1;
73118   if (!argp1) {
73119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73120     return 0;
73121   }
73122   arg1 = *argp1;
73123   {
73124     try {
73125       result = Dali::Toolkit::Model3dView::DownCast(arg1);
73126     } catch (std::out_of_range& e) {
73127       {
73128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73129       };
73130     } catch (std::exception& e) {
73131       {
73132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73133       };
73134     } catch (Dali::DaliException e) {
73135       {
73136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73137       };
73138     } catch (...) {
73139       {
73140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73141       };
73142     }
73143   }
73144
73145   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
73146   return jresult;
73147 }
73148
73149
73150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
73151   int jresult ;
73152   int result;
73153
73154   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
73155   jresult = (int)result;
73156   return jresult;
73157 }
73158
73159
73160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
73161   int jresult ;
73162   int result;
73163
73164   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
73165   jresult = (int)result;
73166   return jresult;
73167 }
73168
73169
73170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
73171   int jresult ;
73172   int result;
73173
73174   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
73175   jresult = (int)result;
73176   return jresult;
73177 }
73178
73179
73180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
73181   int jresult ;
73182   int result;
73183
73184   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
73185   jresult = (int)result;
73186   return jresult;
73187 }
73188
73189
73190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
73191   int jresult ;
73192   int result;
73193
73194   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
73195   jresult = (int)result;
73196   return jresult;
73197 }
73198
73199
73200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
73201   int jresult ;
73202   int result;
73203
73204   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
73205   jresult = (int)result;
73206   return jresult;
73207 }
73208
73209
73210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
73211   int jresult ;
73212   int result;
73213
73214   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
73215   jresult = (int)result;
73216   return jresult;
73217 }
73218
73219
73220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
73221   int jresult ;
73222   int result;
73223
73224   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
73225   jresult = (int)result;
73226   return jresult;
73227 }
73228
73229
73230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
73231   int jresult ;
73232   int result;
73233
73234   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
73235   jresult = (int)result;
73236   return jresult;
73237 }
73238
73239
73240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
73241   void * jresult ;
73242   Dali::Toolkit::ScrollBar::Property *result = 0 ;
73243
73244   {
73245     try {
73246       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (Dali::DaliException e) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73258       };
73259     } catch (...) {
73260       {
73261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73262       };
73263     }
73264   }
73265
73266   jresult = (void *)result;
73267   return jresult;
73268 }
73269
73270
73271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
73272   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
73273
73274   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
73275   {
73276     try {
73277       delete arg1;
73278     } catch (std::out_of_range& e) {
73279       {
73280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73281       };
73282     } catch (std::exception& e) {
73283       {
73284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73285       };
73286     } catch (Dali::DaliException e) {
73287       {
73288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73289       };
73290     } catch (...) {
73291       {
73292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73293       };
73294     }
73295   }
73296
73297 }
73298
73299
73300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
73301   void * jresult ;
73302   Dali::Toolkit::ScrollBar *result = 0 ;
73303
73304   {
73305     try {
73306       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
73307     } catch (std::out_of_range& e) {
73308       {
73309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73310       };
73311     } catch (std::exception& e) {
73312       {
73313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73314       };
73315     } catch (Dali::DaliException e) {
73316       {
73317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73318       };
73319     } catch (...) {
73320       {
73321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73322       };
73323     }
73324   }
73325
73326   jresult = (void *)result;
73327   return jresult;
73328 }
73329
73330
73331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
73332   void * jresult ;
73333   Dali::Toolkit::ScrollBar *arg1 = 0 ;
73334   Dali::Toolkit::ScrollBar *result = 0 ;
73335
73336   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73337   if (!arg1) {
73338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73339     return 0;
73340   }
73341   {
73342     try {
73343       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
73344     } catch (std::out_of_range& e) {
73345       {
73346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73347       };
73348     } catch (std::exception& e) {
73349       {
73350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73351       };
73352     } catch (Dali::DaliException e) {
73353       {
73354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73355       };
73356     } catch (...) {
73357       {
73358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73359       };
73360     }
73361   }
73362
73363   jresult = (void *)result;
73364   return jresult;
73365 }
73366
73367
73368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
73369   void * jresult ;
73370   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73371   Dali::Toolkit::ScrollBar *arg2 = 0 ;
73372   Dali::Toolkit::ScrollBar *result = 0 ;
73373
73374   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73375   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
73376   if (!arg2) {
73377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
73378     return 0;
73379   }
73380   {
73381     try {
73382       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
73383     } catch (std::out_of_range& e) {
73384       {
73385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73386       };
73387     } catch (std::exception& e) {
73388       {
73389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73390       };
73391     } catch (Dali::DaliException e) {
73392       {
73393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73394       };
73395     } catch (...) {
73396       {
73397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73398       };
73399     }
73400   }
73401
73402   jresult = (void *)result;
73403   return jresult;
73404 }
73405
73406
73407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
73408   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73409
73410   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73411   {
73412     try {
73413       delete arg1;
73414     } catch (std::out_of_range& e) {
73415       {
73416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73417       };
73418     } catch (std::exception& e) {
73419       {
73420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73421       };
73422     } catch (Dali::DaliException e) {
73423       {
73424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73425       };
73426     } catch (...) {
73427       {
73428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73429       };
73430     }
73431   }
73432
73433 }
73434
73435
73436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
73437   void * jresult ;
73438   Dali::Toolkit::ScrollBar::Direction arg1 ;
73439   Dali::Toolkit::ScrollBar result;
73440
73441   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
73442   {
73443     try {
73444       result = Dali::Toolkit::ScrollBar::New(arg1);
73445     } catch (std::out_of_range& e) {
73446       {
73447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73448       };
73449     } catch (std::exception& e) {
73450       {
73451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73452       };
73453     } catch (Dali::DaliException e) {
73454       {
73455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73456       };
73457     } catch (...) {
73458       {
73459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73460       };
73461     }
73462   }
73463
73464   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73465   return jresult;
73466 }
73467
73468
73469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
73470   void * jresult ;
73471   Dali::Toolkit::ScrollBar result;
73472
73473   {
73474     try {
73475       result = Dali::Toolkit::ScrollBar::New();
73476     } catch (std::out_of_range& e) {
73477       {
73478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73479       };
73480     } catch (std::exception& e) {
73481       {
73482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73483       };
73484     } catch (Dali::DaliException e) {
73485       {
73486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73487       };
73488     } catch (...) {
73489       {
73490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73491       };
73492     }
73493   }
73494
73495   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73496   return jresult;
73497 }
73498
73499
73500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
73501   void * jresult ;
73502   Dali::BaseHandle arg1 ;
73503   Dali::BaseHandle *argp1 ;
73504   Dali::Toolkit::ScrollBar result;
73505
73506   argp1 = (Dali::BaseHandle *)jarg1;
73507   if (!argp1) {
73508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73509     return 0;
73510   }
73511   arg1 = *argp1;
73512   {
73513     try {
73514       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
73515     } catch (std::out_of_range& e) {
73516       {
73517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73518       };
73519     } catch (std::exception& e) {
73520       {
73521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73522       };
73523     } catch (Dali::DaliException e) {
73524       {
73525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73526       };
73527     } catch (...) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73530       };
73531     }
73532   }
73533
73534   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
73540   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73541   Dali::Handle arg2 ;
73542   Dali::Property::Index arg3 ;
73543   Dali::Property::Index arg4 ;
73544   Dali::Property::Index arg5 ;
73545   Dali::Property::Index arg6 ;
73546   Dali::Handle *argp2 ;
73547
73548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73549   argp2 = (Dali::Handle *)jarg2;
73550   if (!argp2) {
73551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
73552     return ;
73553   }
73554   arg2 = *argp2;
73555   arg3 = (Dali::Property::Index)jarg3;
73556   arg4 = (Dali::Property::Index)jarg4;
73557   arg5 = (Dali::Property::Index)jarg5;
73558   arg6 = (Dali::Property::Index)jarg6;
73559   {
73560     try {
73561       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
73562     } catch (std::out_of_range& e) {
73563       {
73564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73565       };
73566     } catch (std::exception& e) {
73567       {
73568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73569       };
73570     } catch (Dali::DaliException e) {
73571       {
73572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73573       };
73574     } catch (...) {
73575       {
73576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73577       };
73578     }
73579   }
73580
73581 }
73582
73583
73584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
73585   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73586   Dali::Actor arg2 ;
73587   Dali::Actor *argp2 ;
73588
73589   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73590   argp2 = (Dali::Actor *)jarg2;
73591   if (!argp2) {
73592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73593     return ;
73594   }
73595   arg2 = *argp2;
73596   {
73597     try {
73598       (arg1)->SetScrollIndicator(arg2);
73599     } catch (std::out_of_range& e) {
73600       {
73601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73602       };
73603     } catch (std::exception& e) {
73604       {
73605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73606       };
73607     } catch (Dali::DaliException e) {
73608       {
73609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73610       };
73611     } catch (...) {
73612       {
73613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73614       };
73615     }
73616   }
73617
73618 }
73619
73620
73621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
73622   void * jresult ;
73623   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73624   Dali::Actor result;
73625
73626   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73627   {
73628     try {
73629       result = (arg1)->GetScrollIndicator();
73630     } catch (std::out_of_range& e) {
73631       {
73632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73633       };
73634     } catch (std::exception& e) {
73635       {
73636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73637       };
73638     } catch (Dali::DaliException e) {
73639       {
73640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73641       };
73642     } catch (...) {
73643       {
73644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73645       };
73646     }
73647   }
73648
73649   jresult = new Dali::Actor((const Dali::Actor &)result);
73650   return jresult;
73651 }
73652
73653
73654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
73655   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73656   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
73657
73658   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73659   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
73660   if (!arg2) {
73661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
73662     return ;
73663   }
73664   {
73665     try {
73666       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
73667     } catch (std::out_of_range& e) {
73668       {
73669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73670       };
73671     } catch (std::exception& e) {
73672       {
73673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73674       };
73675     } catch (Dali::DaliException e) {
73676       {
73677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73678       };
73679     } catch (...) {
73680       {
73681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73682       };
73683     }
73684   }
73685
73686 }
73687
73688
73689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
73690   void * jresult ;
73691   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73692
73693   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73694   {
73695     try {
73696       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()));
73697     } catch (std::out_of_range& e) {
73698       {
73699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73700       };
73701     } catch (std::exception& e) {
73702       {
73703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73704       };
73705     } catch (...) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73708       };
73709     }
73710   }
73711   return jresult;
73712 }
73713
73714
73715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
73716   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73717   Dali::Toolkit::ScrollBar::Direction arg2 ;
73718
73719   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73720   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
73721   {
73722     try {
73723       (arg1)->SetScrollDirection(arg2);
73724     } catch (std::out_of_range& e) {
73725       {
73726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73727       };
73728     } catch (std::exception& e) {
73729       {
73730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73731       };
73732     } catch (Dali::DaliException e) {
73733       {
73734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73735       };
73736     } catch (...) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73739       };
73740     }
73741   }
73742
73743 }
73744
73745
73746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
73747   int jresult ;
73748   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73749   Dali::Toolkit::ScrollBar::Direction result;
73750
73751   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73752   {
73753     try {
73754       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (Dali::DaliException e) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773
73774   jresult = (int)result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73780   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73781   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73782
73783   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73784   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73785   {
73786     try {
73787       (arg1)->SetIndicatorHeightPolicy(arg2);
73788     } catch (std::out_of_range& e) {
73789       {
73790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73791       };
73792     } catch (std::exception& e) {
73793       {
73794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73795       };
73796     } catch (Dali::DaliException e) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73803       };
73804     }
73805   }
73806
73807 }
73808
73809
73810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73811   int jresult ;
73812   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73813   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73814
73815   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73816   {
73817     try {
73818       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73826       };
73827     } catch (Dali::DaliException e) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73830       };
73831     } catch (...) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73834       };
73835     }
73836   }
73837
73838   jresult = (int)result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73844   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73845   float arg2 ;
73846
73847   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73848   arg2 = (float)jarg2;
73849   {
73850     try {
73851       (arg1)->SetIndicatorFixedHeight(arg2);
73852     } catch (std::out_of_range& e) {
73853       {
73854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73855       };
73856     } catch (std::exception& e) {
73857       {
73858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73859       };
73860     } catch (Dali::DaliException e) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73867       };
73868     }
73869   }
73870
73871 }
73872
73873
73874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73875   float jresult ;
73876   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73877   float result;
73878
73879   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73880   {
73881     try {
73882       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73883     } catch (std::out_of_range& e) {
73884       {
73885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73886       };
73887     } catch (std::exception& e) {
73888       {
73889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (Dali::DaliException e) {
73892       {
73893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73894       };
73895     } catch (...) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73898       };
73899     }
73900   }
73901
73902   jresult = result;
73903   return jresult;
73904 }
73905
73906
73907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73908   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73909   float arg2 ;
73910
73911   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73912   arg2 = (float)jarg2;
73913   {
73914     try {
73915       (arg1)->SetIndicatorShowDuration(arg2);
73916     } catch (std::out_of_range& e) {
73917       {
73918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73919       };
73920     } catch (std::exception& e) {
73921       {
73922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73923       };
73924     } catch (Dali::DaliException e) {
73925       {
73926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73927       };
73928     } catch (...) {
73929       {
73930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73931       };
73932     }
73933   }
73934
73935 }
73936
73937
73938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73939   float jresult ;
73940   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73941   float result;
73942
73943   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73944   {
73945     try {
73946       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73947     } catch (std::out_of_range& e) {
73948       {
73949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73950       };
73951     } catch (std::exception& e) {
73952       {
73953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73954       };
73955     } catch (Dali::DaliException e) {
73956       {
73957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73958       };
73959     } catch (...) {
73960       {
73961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73962       };
73963     }
73964   }
73965
73966   jresult = result;
73967   return jresult;
73968 }
73969
73970
73971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73972   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73973   float arg2 ;
73974
73975   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73976   arg2 = (float)jarg2;
73977   {
73978     try {
73979       (arg1)->SetIndicatorHideDuration(arg2);
73980     } catch (std::out_of_range& e) {
73981       {
73982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (std::exception& e) {
73985       {
73986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73987       };
73988     } catch (Dali::DaliException e) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73991       };
73992     } catch (...) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73995       };
73996     }
73997   }
73998
73999 }
74000
74001
74002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
74003   float jresult ;
74004   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74005   float result;
74006
74007   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74008   {
74009     try {
74010       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74018       };
74019     } catch (Dali::DaliException e) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74022       };
74023     } catch (...) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74026       };
74027     }
74028   }
74029
74030   jresult = result;
74031   return jresult;
74032 }
74033
74034
74035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
74036   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74037
74038   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74039   {
74040     try {
74041       (arg1)->ShowIndicator();
74042     } catch (std::out_of_range& e) {
74043       {
74044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74045       };
74046     } catch (std::exception& e) {
74047       {
74048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74049       };
74050     } catch (Dali::DaliException e) {
74051       {
74052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74053       };
74054     } catch (...) {
74055       {
74056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74057       };
74058     }
74059   }
74060
74061 }
74062
74063
74064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
74065   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74066
74067   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74068   {
74069     try {
74070       (arg1)->HideIndicator();
74071     } catch (std::out_of_range& e) {
74072       {
74073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74074       };
74075     } catch (std::exception& e) {
74076       {
74077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74078       };
74079     } catch (Dali::DaliException e) {
74080       {
74081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74082       };
74083     } catch (...) {
74084       {
74085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74086       };
74087     }
74088   }
74089
74090 }
74091
74092
74093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
74094   void * jresult ;
74095   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74096   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
74097
74098   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74099   {
74100     try {
74101       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
74102     } catch (std::out_of_range& e) {
74103       {
74104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74105       };
74106     } catch (std::exception& e) {
74107       {
74108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (Dali::DaliException e) {
74111       {
74112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74113       };
74114     } catch (...) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74117       };
74118     }
74119   }
74120
74121   jresult = (void *)result;
74122   return jresult;
74123 }
74124
74125
74126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
74127   void * jresult ;
74128   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
74129   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
74130
74131   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
74132   {
74133     try {
74134       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
74135     } catch (std::out_of_range& e) {
74136       {
74137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74138       };
74139     } catch (std::exception& e) {
74140       {
74141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74142       };
74143     } catch (Dali::DaliException e) {
74144       {
74145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74146       };
74147     } catch (...) {
74148       {
74149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74150       };
74151     }
74152   }
74153
74154   jresult = (void *)result;
74155   return jresult;
74156 }
74157
74158
74159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
74160   int jresult ;
74161   int result;
74162
74163   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
74164   jresult = (int)result;
74165   return jresult;
74166 }
74167
74168
74169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
74170   int jresult ;
74171   int result;
74172
74173   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
74174   jresult = (int)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
74180   int jresult ;
74181   int result;
74182
74183   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
74184   jresult = (int)result;
74185   return jresult;
74186 }
74187
74188
74189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
74190   int jresult ;
74191   int result;
74192
74193   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
74194   jresult = (int)result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
74200   int jresult ;
74201   int result;
74202
74203   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
74204   jresult = (int)result;
74205   return jresult;
74206 }
74207
74208
74209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
74210   int jresult ;
74211   int result;
74212
74213   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
74214   jresult = (int)result;
74215   return jresult;
74216 }
74217
74218
74219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
74220   int jresult ;
74221   int result;
74222
74223   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
74224   jresult = (int)result;
74225   return jresult;
74226 }
74227
74228
74229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
74230   int jresult ;
74231   int result;
74232
74233   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
74234   jresult = (int)result;
74235   return jresult;
74236 }
74237
74238
74239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
74240   int jresult ;
74241   int result;
74242
74243   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
74244   jresult = (int)result;
74245   return jresult;
74246 }
74247
74248
74249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
74250   int jresult ;
74251   int result;
74252
74253   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
74254   jresult = (int)result;
74255   return jresult;
74256 }
74257
74258
74259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
74260   int jresult ;
74261   int result;
74262
74263   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
74264   jresult = (int)result;
74265   return jresult;
74266 }
74267
74268
74269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
74270   int jresult ;
74271   int result;
74272
74273   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
74274   jresult = (int)result;
74275   return jresult;
74276 }
74277
74278
74279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
74280   int jresult ;
74281   int result;
74282
74283   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
74284   jresult = (int)result;
74285   return jresult;
74286 }
74287
74288
74289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
74290   int jresult ;
74291   int result;
74292
74293   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
74294   jresult = (int)result;
74295   return jresult;
74296 }
74297
74298
74299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
74300   void * jresult ;
74301   Dali::Toolkit::Scrollable::Property *result = 0 ;
74302
74303   {
74304     try {
74305       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
74306     } catch (std::out_of_range& e) {
74307       {
74308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74309       };
74310     } catch (std::exception& e) {
74311       {
74312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (Dali::DaliException e) {
74315       {
74316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74317       };
74318     } catch (...) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74321       };
74322     }
74323   }
74324
74325   jresult = (void *)result;
74326   return jresult;
74327 }
74328
74329
74330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
74331   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
74332
74333   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
74334   {
74335     try {
74336       delete arg1;
74337     } catch (std::out_of_range& e) {
74338       {
74339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74340       };
74341     } catch (std::exception& e) {
74342       {
74343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74344       };
74345     } catch (Dali::DaliException e) {
74346       {
74347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74348       };
74349     } catch (...) {
74350       {
74351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74352       };
74353     }
74354   }
74355
74356 }
74357
74358
74359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
74360   void * jresult ;
74361   Dali::Toolkit::Scrollable *result = 0 ;
74362
74363   {
74364     try {
74365       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
74366     } catch (std::out_of_range& e) {
74367       {
74368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74369       };
74370     } catch (std::exception& e) {
74371       {
74372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74373       };
74374     } catch (Dali::DaliException e) {
74375       {
74376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74377       };
74378     } catch (...) {
74379       {
74380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74381       };
74382     }
74383   }
74384
74385   jresult = (void *)result;
74386   return jresult;
74387 }
74388
74389
74390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
74391   void * jresult ;
74392   Dali::Toolkit::Scrollable *arg1 = 0 ;
74393   Dali::Toolkit::Scrollable *result = 0 ;
74394
74395   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74396   if (!arg1) {
74397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74398     return 0;
74399   }
74400   {
74401     try {
74402       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74418       };
74419     }
74420   }
74421
74422   jresult = (void *)result;
74423   return jresult;
74424 }
74425
74426
74427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
74428   void * jresult ;
74429   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74430   Dali::Toolkit::Scrollable *arg2 = 0 ;
74431   Dali::Toolkit::Scrollable *result = 0 ;
74432
74433   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74434   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
74435   if (!arg2) {
74436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
74437     return 0;
74438   }
74439   {
74440     try {
74441       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
74442     } catch (std::out_of_range& e) {
74443       {
74444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74445       };
74446     } catch (std::exception& e) {
74447       {
74448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74449       };
74450     } catch (Dali::DaliException e) {
74451       {
74452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74453       };
74454     } catch (...) {
74455       {
74456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74457       };
74458     }
74459   }
74460
74461   jresult = (void *)result;
74462   return jresult;
74463 }
74464
74465
74466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
74467   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74468
74469   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74470   {
74471     try {
74472       delete arg1;
74473     } catch (std::out_of_range& e) {
74474       {
74475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74476       };
74477     } catch (std::exception& e) {
74478       {
74479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74480       };
74481     } catch (Dali::DaliException e) {
74482       {
74483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74484       };
74485     } catch (...) {
74486       {
74487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74488       };
74489     }
74490   }
74491
74492 }
74493
74494
74495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
74496   void * jresult ;
74497   Dali::BaseHandle arg1 ;
74498   Dali::BaseHandle *argp1 ;
74499   Dali::Toolkit::Scrollable result;
74500
74501   argp1 = (Dali::BaseHandle *)jarg1;
74502   if (!argp1) {
74503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74504     return 0;
74505   }
74506   arg1 = *argp1;
74507   {
74508     try {
74509       result = Dali::Toolkit::Scrollable::DownCast(arg1);
74510     } catch (std::out_of_range& e) {
74511       {
74512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74513       };
74514     } catch (std::exception& e) {
74515       {
74516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74517       };
74518     } catch (Dali::DaliException e) {
74519       {
74520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74521       };
74522     } catch (...) {
74523       {
74524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74525       };
74526     }
74527   }
74528
74529   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
74530   return jresult;
74531 }
74532
74533
74534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
74535   unsigned int jresult ;
74536   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74537   bool result;
74538
74539   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74540   {
74541     try {
74542       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
74543     } catch (std::out_of_range& e) {
74544       {
74545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74546       };
74547     } catch (std::exception& e) {
74548       {
74549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74550       };
74551     } catch (Dali::DaliException e) {
74552       {
74553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74554       };
74555     } catch (...) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74558       };
74559     }
74560   }
74561
74562   jresult = result;
74563   return jresult;
74564 }
74565
74566
74567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
74568   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74569   bool arg2 ;
74570
74571   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74572   arg2 = jarg2 ? true : false;
74573   {
74574     try {
74575       (arg1)->SetOvershootEnabled(arg2);
74576     } catch (std::out_of_range& e) {
74577       {
74578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74579       };
74580     } catch (std::exception& e) {
74581       {
74582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74583       };
74584     } catch (Dali::DaliException e) {
74585       {
74586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74587       };
74588     } catch (...) {
74589       {
74590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74591       };
74592     }
74593   }
74594
74595 }
74596
74597
74598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
74599   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74600   Dali::Vector4 *arg2 = 0 ;
74601
74602   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74603   arg2 = (Dali::Vector4 *)jarg2;
74604   if (!arg2) {
74605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
74606     return ;
74607   }
74608   {
74609     try {
74610       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
74611     } catch (std::out_of_range& e) {
74612       {
74613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74614       };
74615     } catch (std::exception& e) {
74616       {
74617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74618       };
74619     } catch (Dali::DaliException e) {
74620       {
74621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74622       };
74623     } catch (...) {
74624       {
74625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74626       };
74627     }
74628   }
74629
74630 }
74631
74632
74633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
74634   void * jresult ;
74635   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74636   Dali::Vector4 result;
74637
74638   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74639   {
74640     try {
74641       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
74642     } catch (std::out_of_range& e) {
74643       {
74644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74645       };
74646     } catch (std::exception& e) {
74647       {
74648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74649       };
74650     } catch (Dali::DaliException e) {
74651       {
74652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74653       };
74654     } catch (...) {
74655       {
74656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74657       };
74658     }
74659   }
74660
74661   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
74662   return jresult;
74663 }
74664
74665
74666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
74667   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74668   float arg2 ;
74669
74670   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74671   arg2 = (float)jarg2;
74672   {
74673     try {
74674       (arg1)->SetOvershootAnimationSpeed(arg2);
74675     } catch (std::out_of_range& e) {
74676       {
74677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74678       };
74679     } catch (std::exception& e) {
74680       {
74681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74682       };
74683     } catch (Dali::DaliException e) {
74684       {
74685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74686       };
74687     } catch (...) {
74688       {
74689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74690       };
74691     }
74692   }
74693
74694 }
74695
74696
74697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
74698   float jresult ;
74699   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74700   float result;
74701
74702   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74703   {
74704     try {
74705       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
74706     } catch (std::out_of_range& e) {
74707       {
74708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74709       };
74710     } catch (std::exception& e) {
74711       {
74712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74713       };
74714     } catch (Dali::DaliException e) {
74715       {
74716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74717       };
74718     } catch (...) {
74719       {
74720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74721       };
74722     }
74723   }
74724
74725   jresult = result;
74726   return jresult;
74727 }
74728
74729
74730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
74731   void * jresult ;
74732   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74733   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
74734
74735   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74736   {
74737     try {
74738       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
74739     } catch (std::out_of_range& e) {
74740       {
74741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74742       };
74743     } catch (std::exception& e) {
74744       {
74745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74746       };
74747     } catch (Dali::DaliException e) {
74748       {
74749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74750       };
74751     } catch (...) {
74752       {
74753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74754       };
74755     }
74756   }
74757
74758   jresult = (void *)result;
74759   return jresult;
74760 }
74761
74762
74763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74764   void * jresult ;
74765   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74766   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74767
74768   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74769   {
74770     try {
74771       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74772     } catch (std::out_of_range& e) {
74773       {
74774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74775       };
74776     } catch (std::exception& e) {
74777       {
74778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74779       };
74780     } catch (Dali::DaliException e) {
74781       {
74782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74783       };
74784     } catch (...) {
74785       {
74786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74787       };
74788     }
74789   }
74790
74791   jresult = (void *)result;
74792   return jresult;
74793 }
74794
74795
74796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74797   void * jresult ;
74798   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74799   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74800
74801   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74802   {
74803     try {
74804       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74805     } catch (std::out_of_range& e) {
74806       {
74807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74808       };
74809     } catch (std::exception& e) {
74810       {
74811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74812       };
74813     } catch (Dali::DaliException e) {
74814       {
74815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74816       };
74817     } catch (...) {
74818       {
74819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74820       };
74821     }
74822   }
74823
74824   jresult = (void *)result;
74825   return jresult;
74826 }
74827
74828
74829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74830   unsigned int jresult ;
74831   Dali::Toolkit::ControlOrientation::Type arg1 ;
74832   bool result;
74833
74834   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74835   {
74836     try {
74837       result = (bool)Dali::Toolkit::IsVertical(arg1);
74838     } catch (std::out_of_range& e) {
74839       {
74840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74841       };
74842     } catch (std::exception& e) {
74843       {
74844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74845       };
74846     } catch (Dali::DaliException e) {
74847       {
74848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74849       };
74850     } catch (...) {
74851       {
74852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74853       };
74854     }
74855   }
74856
74857   jresult = result;
74858   return jresult;
74859 }
74860
74861
74862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74863   unsigned int jresult ;
74864   Dali::Toolkit::ControlOrientation::Type arg1 ;
74865   bool result;
74866
74867   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74868   {
74869     try {
74870       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74871     } catch (std::out_of_range& e) {
74872       {
74873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74874       };
74875     } catch (std::exception& e) {
74876       {
74877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74878       };
74879     } catch (Dali::DaliException e) {
74880       {
74881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74882       };
74883     } catch (...) {
74884       {
74885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74886       };
74887     }
74888   }
74889
74890   jresult = result;
74891   return jresult;
74892 }
74893
74894
74895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74896   void * jresult ;
74897   unsigned int arg1 ;
74898   unsigned int arg2 ;
74899   Dali::Toolkit::ItemRange *result = 0 ;
74900
74901   arg1 = (unsigned int)jarg1;
74902   arg2 = (unsigned int)jarg2;
74903   {
74904     try {
74905       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74906     } catch (std::out_of_range& e) {
74907       {
74908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74909       };
74910     } catch (std::exception& e) {
74911       {
74912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74913       };
74914     } catch (Dali::DaliException e) {
74915       {
74916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74917       };
74918     } catch (...) {
74919       {
74920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74921       };
74922     }
74923   }
74924
74925   jresult = (void *)result;
74926   return jresult;
74927 }
74928
74929
74930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74931   void * jresult ;
74932   Dali::Toolkit::ItemRange *arg1 = 0 ;
74933   Dali::Toolkit::ItemRange *result = 0 ;
74934
74935   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74936   if (!arg1) {
74937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74938     return 0;
74939   }
74940   {
74941     try {
74942       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74943     } catch (std::out_of_range& e) {
74944       {
74945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74946       };
74947     } catch (std::exception& e) {
74948       {
74949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74950       };
74951     } catch (Dali::DaliException e) {
74952       {
74953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74954       };
74955     } catch (...) {
74956       {
74957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74958       };
74959     }
74960   }
74961
74962   jresult = (void *)result;
74963   return jresult;
74964 }
74965
74966
74967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74968   void * jresult ;
74969   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74970   Dali::Toolkit::ItemRange *arg2 = 0 ;
74971   Dali::Toolkit::ItemRange *result = 0 ;
74972
74973   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74974   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74975   if (!arg2) {
74976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74977     return 0;
74978   }
74979   {
74980     try {
74981       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74982     } catch (std::out_of_range& e) {
74983       {
74984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74985       };
74986     } catch (std::exception& e) {
74987       {
74988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74989       };
74990     } catch (Dali::DaliException e) {
74991       {
74992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74993       };
74994     } catch (...) {
74995       {
74996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74997       };
74998     }
74999   }
75000
75001   jresult = (void *)result;
75002   return jresult;
75003 }
75004
75005
75006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
75007   unsigned int jresult ;
75008   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75009   unsigned int arg2 ;
75010   bool result;
75011
75012   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75013   arg2 = (unsigned int)jarg2;
75014   {
75015     try {
75016       result = (bool)(arg1)->Within(arg2);
75017     } catch (std::out_of_range& e) {
75018       {
75019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75020       };
75021     } catch (std::exception& e) {
75022       {
75023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75024       };
75025     } catch (Dali::DaliException e) {
75026       {
75027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75028       };
75029     } catch (...) {
75030       {
75031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75032       };
75033     }
75034   }
75035
75036   jresult = result;
75037   return jresult;
75038 }
75039
75040
75041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
75042   void * jresult ;
75043   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75044   Dali::Toolkit::ItemRange *arg2 = 0 ;
75045   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75046
75047   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75048   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
75049   if (!arg2) {
75050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
75051     return 0;
75052   }
75053   {
75054     try {
75055       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
75056     } catch (std::out_of_range& e) {
75057       {
75058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75059       };
75060     } catch (std::exception& e) {
75061       {
75062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75063       };
75064     } catch (Dali::DaliException e) {
75065       {
75066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75067       };
75068     } catch (...) {
75069       {
75070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75071       };
75072     }
75073   }
75074
75075   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75076   return jresult;
75077 }
75078
75079
75080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
75081   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75082   unsigned int arg2 ;
75083
75084   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75085   arg2 = (unsigned int)jarg2;
75086   if (arg1) (arg1)->begin = arg2;
75087 }
75088
75089
75090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
75091   unsigned int jresult ;
75092   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75093   unsigned int result;
75094
75095   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75096   result = (unsigned int) ((arg1)->begin);
75097   jresult = result;
75098   return jresult;
75099 }
75100
75101
75102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
75103   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75104   unsigned int arg2 ;
75105
75106   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75107   arg2 = (unsigned int)jarg2;
75108   if (arg1) (arg1)->end = arg2;
75109 }
75110
75111
75112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
75113   unsigned int jresult ;
75114   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75115   unsigned int result;
75116
75117   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75118   result = (unsigned int) ((arg1)->end);
75119   jresult = result;
75120   return jresult;
75121 }
75122
75123
75124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
75125   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
75126
75127   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
75128   {
75129     try {
75130       delete arg1;
75131     } catch (std::out_of_range& e) {
75132       {
75133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75134       };
75135     } catch (std::exception& e) {
75136       {
75137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75138       };
75139     } catch (Dali::DaliException e) {
75140       {
75141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75142       };
75143     } catch (...) {
75144       {
75145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75146       };
75147     }
75148   }
75149
75150 }
75151
75152
75153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
75154   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75155
75156   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75157   {
75158     try {
75159       delete arg1;
75160     } catch (std::out_of_range& e) {
75161       {
75162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75163       };
75164     } catch (std::exception& e) {
75165       {
75166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75167       };
75168     } catch (Dali::DaliException e) {
75169       {
75170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75171       };
75172     } catch (...) {
75173       {
75174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75175       };
75176     }
75177   }
75178
75179 }
75180
75181
75182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
75183   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75184   Dali::Toolkit::ControlOrientation::Type arg2 ;
75185
75186   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75187   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
75188   {
75189     try {
75190       (arg1)->SetOrientation(arg2);
75191     } catch (std::out_of_range& e) {
75192       {
75193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75194       };
75195     } catch (std::exception& e) {
75196       {
75197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75198       };
75199     } catch (Dali::DaliException e) {
75200       {
75201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75202       };
75203     } catch (...) {
75204       {
75205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75206       };
75207     }
75208   }
75209
75210 }
75211
75212
75213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
75214   int jresult ;
75215   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75216   Dali::Toolkit::ControlOrientation::Type result;
75217
75218   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75219   {
75220     try {
75221       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
75222     } catch (std::out_of_range& e) {
75223       {
75224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75225       };
75226     } catch (std::exception& e) {
75227       {
75228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75229       };
75230     } catch (Dali::DaliException e) {
75231       {
75232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75233       };
75234     } catch (...) {
75235       {
75236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75237       };
75238     }
75239   }
75240
75241   jresult = (int)result;
75242   return jresult;
75243 }
75244
75245
75246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
75247   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75248   Dali::Property::Map *arg2 = 0 ;
75249
75250   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75251   arg2 = (Dali::Property::Map *)jarg2;
75252   if (!arg2) {
75253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
75254     return ;
75255   }
75256   {
75257     try {
75258       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
75259     } catch (std::out_of_range& e) {
75260       {
75261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75262       };
75263     } catch (std::exception& e) {
75264       {
75265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75266       };
75267     } catch (Dali::DaliException e) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75270       };
75271     } catch (...) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75274       };
75275     }
75276   }
75277
75278 }
75279
75280
75281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
75282   void * jresult ;
75283   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75284   Dali::Property::Map result;
75285
75286   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75287   {
75288     try {
75289       result = (arg1)->GetLayoutProperties();
75290     } catch (std::out_of_range& e) {
75291       {
75292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75293       };
75294     } catch (std::exception& e) {
75295       {
75296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75297       };
75298     } catch (Dali::DaliException e) {
75299       {
75300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75301       };
75302     } catch (...) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75305       };
75306     }
75307   }
75308
75309   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
75310   return jresult;
75311 }
75312
75313
75314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75315   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75316   unsigned int arg2 ;
75317   Dali::Vector3 *arg3 = 0 ;
75318   Dali::Vector3 *arg4 = 0 ;
75319
75320   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75321   arg2 = (unsigned int)jarg2;
75322   arg3 = (Dali::Vector3 *)jarg3;
75323   if (!arg3) {
75324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75325     return ;
75326   }
75327   arg4 = (Dali::Vector3 *)jarg4;
75328   if (!arg4) {
75329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75330     return ;
75331   }
75332   {
75333     try {
75334       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75335     } catch (std::out_of_range& e) {
75336       {
75337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75338       };
75339     } catch (std::exception& e) {
75340       {
75341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75342       };
75343     } catch (Dali::DaliException e) {
75344       {
75345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75346       };
75347     } catch (...) {
75348       {
75349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75350       };
75351     }
75352   }
75353
75354 }
75355
75356
75357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
75358   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75359   Dali::Vector3 *arg2 = 0 ;
75360
75361   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75362   arg2 = (Dali::Vector3 *)jarg2;
75363   if (!arg2) {
75364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75365     return ;
75366   }
75367   {
75368     try {
75369       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
75370     } catch (std::out_of_range& e) {
75371       {
75372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75373       };
75374     } catch (std::exception& e) {
75375       {
75376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75377       };
75378     } catch (Dali::DaliException e) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75385       };
75386     }
75387   }
75388
75389 }
75390
75391
75392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
75393   float jresult ;
75394   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75395   unsigned int arg2 ;
75396   Dali::Vector3 arg3 ;
75397   Dali::Vector3 *argp3 ;
75398   float result;
75399
75400   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75401   arg2 = (unsigned int)jarg2;
75402   argp3 = (Dali::Vector3 *)jarg3;
75403   if (!argp3) {
75404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75405     return 0;
75406   }
75407   arg3 = *argp3;
75408   {
75409     try {
75410       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
75411     } catch (std::out_of_range& e) {
75412       {
75413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75414       };
75415     } catch (std::exception& e) {
75416       {
75417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75418       };
75419     } catch (Dali::DaliException e) {
75420       {
75421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75422       };
75423     } catch (...) {
75424       {
75425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75426       };
75427     }
75428   }
75429
75430   jresult = result;
75431   return jresult;
75432 }
75433
75434
75435 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
75436   float jresult ;
75437   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75438   float arg2 ;
75439   float result;
75440
75441   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75442   arg2 = (float)jarg2;
75443   {
75444     try {
75445       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
75446     } catch (std::out_of_range& e) {
75447       {
75448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75449       };
75450     } catch (std::exception& e) {
75451       {
75452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75453       };
75454     } catch (Dali::DaliException e) {
75455       {
75456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75457       };
75458     } catch (...) {
75459       {
75460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75461       };
75462     }
75463   }
75464
75465   jresult = result;
75466   return jresult;
75467 }
75468
75469
75470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
75471   float jresult ;
75472   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75473   unsigned int arg2 ;
75474   float result;
75475
75476   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75477   arg2 = (unsigned int)jarg2;
75478   {
75479     try {
75480       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
75481     } catch (std::out_of_range& e) {
75482       {
75483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75484       };
75485     } catch (std::exception& e) {
75486       {
75487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (Dali::DaliException e) {
75490       {
75491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75492       };
75493     } catch (...) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75496       };
75497     }
75498   }
75499
75500   jresult = result;
75501   return jresult;
75502 }
75503
75504
75505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
75506   void * jresult ;
75507   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75508   float arg2 ;
75509   Dali::Vector3 arg3 ;
75510   Dali::Vector3 *argp3 ;
75511   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
75512
75513   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75514   arg2 = (float)jarg2;
75515   argp3 = (Dali::Vector3 *)jarg3;
75516   if (!argp3) {
75517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75518     return 0;
75519   }
75520   arg3 = *argp3;
75521   {
75522     try {
75523       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
75524     } catch (std::out_of_range& e) {
75525       {
75526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75527       };
75528     } catch (std::exception& e) {
75529       {
75530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75531       };
75532     } catch (Dali::DaliException e) {
75533       {
75534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75535       };
75536     } catch (...) {
75537       {
75538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75539       };
75540     }
75541   }
75542
75543   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
75544   return jresult;
75545 }
75546
75547
75548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75549   float jresult ;
75550   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75551   int arg2 ;
75552   float arg3 ;
75553   Dali::Vector3 *arg4 = 0 ;
75554   float result;
75555
75556   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75557   arg2 = (int)jarg2;
75558   arg3 = (float)jarg3;
75559   arg4 = (Dali::Vector3 *)jarg4;
75560   if (!arg4) {
75561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75562     return 0;
75563   }
75564   {
75565     try {
75566       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75567     } catch (std::out_of_range& e) {
75568       {
75569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75570       };
75571     } catch (std::exception& e) {
75572       {
75573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75574       };
75575     } catch (Dali::DaliException e) {
75576       {
75577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75578       };
75579     } catch (...) {
75580       {
75581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75582       };
75583     }
75584   }
75585
75586   jresult = result;
75587   return jresult;
75588 }
75589
75590
75591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
75592   unsigned int jresult ;
75593   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75594   Dali::Vector3 arg2 ;
75595   Dali::Vector3 *argp2 ;
75596   unsigned int result;
75597
75598   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75599   argp2 = (Dali::Vector3 *)jarg2;
75600   if (!argp2) {
75601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
75602     return 0;
75603   }
75604   arg2 = *argp2;
75605   {
75606     try {
75607       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
75608     } catch (std::out_of_range& e) {
75609       {
75610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75611       };
75612     } catch (std::exception& e) {
75613       {
75614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75615       };
75616     } catch (Dali::DaliException e) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75619       };
75620     } catch (...) {
75621       {
75622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75623       };
75624     }
75625   }
75626
75627   jresult = result;
75628   return jresult;
75629 }
75630
75631
75632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
75633   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75634   unsigned int arg2 ;
75635   Dali::Vector3 *arg3 = 0 ;
75636   Dali::Vector3 *arg4 = 0 ;
75637
75638   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75639   arg2 = (unsigned int)jarg2;
75640   arg3 = (Dali::Vector3 *)jarg3;
75641   if (!arg3) {
75642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75643     return ;
75644   }
75645   arg4 = (Dali::Vector3 *)jarg4;
75646   if (!arg4) {
75647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
75648     return ;
75649   }
75650   {
75651     try {
75652       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
75653     } catch (std::out_of_range& e) {
75654       {
75655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75656       };
75657     } catch (std::exception& e) {
75658       {
75659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75660       };
75661     } catch (Dali::DaliException e) {
75662       {
75663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75664       };
75665     } catch (...) {
75666       {
75667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75668       };
75669     }
75670   }
75671
75672 }
75673
75674
75675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
75676   void * jresult ;
75677   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75678   Dali::Degree result;
75679
75680   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75681   {
75682     try {
75683       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
75684     } catch (std::out_of_range& e) {
75685       {
75686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75687       };
75688     } catch (std::exception& e) {
75689       {
75690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75691       };
75692     } catch (Dali::DaliException e) {
75693       {
75694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75695       };
75696     } catch (...) {
75697       {
75698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75699       };
75700     }
75701   }
75702
75703   jresult = new Dali::Degree((const Dali::Degree &)result);
75704   return jresult;
75705 }
75706
75707
75708 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
75709   float jresult ;
75710   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75711   float result;
75712
75713   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75714   {
75715     try {
75716       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
75717     } catch (std::out_of_range& e) {
75718       {
75719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75720       };
75721     } catch (std::exception& e) {
75722       {
75723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75724       };
75725     } catch (Dali::DaliException e) {
75726       {
75727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75732       };
75733     }
75734   }
75735
75736   jresult = result;
75737   return jresult;
75738 }
75739
75740
75741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
75742   float jresult ;
75743   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75744   float result;
75745
75746   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75747   {
75748     try {
75749       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75750     } catch (std::out_of_range& e) {
75751       {
75752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75753       };
75754     } catch (std::exception& e) {
75755       {
75756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75757       };
75758     } catch (Dali::DaliException e) {
75759       {
75760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75761       };
75762     } catch (...) {
75763       {
75764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75765       };
75766     }
75767   }
75768
75769   jresult = result;
75770   return jresult;
75771 }
75772
75773
75774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75775   float jresult ;
75776   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75777   float result;
75778
75779   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75780   {
75781     try {
75782       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75783     } catch (std::out_of_range& e) {
75784       {
75785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75786       };
75787     } catch (std::exception& e) {
75788       {
75789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75790       };
75791     } catch (Dali::DaliException e) {
75792       {
75793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75794       };
75795     } catch (...) {
75796       {
75797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75798       };
75799     }
75800   }
75801
75802   jresult = result;
75803   return jresult;
75804 }
75805
75806
75807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75808   int jresult ;
75809   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75810   int arg2 ;
75811   int arg3 ;
75812   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75813   bool arg5 ;
75814   int result;
75815
75816   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75817   arg2 = (int)jarg2;
75818   arg3 = (int)jarg3;
75819   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75820   arg5 = jarg5 ? true : false;
75821   {
75822     try {
75823       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75831       };
75832     } catch (Dali::DaliException e) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75835       };
75836     } catch (...) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75839       };
75840     }
75841   }
75842
75843   jresult = result;
75844   return jresult;
75845 }
75846
75847
75848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75849   float jresult ;
75850   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75851   float result;
75852
75853   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75854   {
75855     try {
75856       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75857     } catch (std::out_of_range& e) {
75858       {
75859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75860       };
75861     } catch (std::exception& e) {
75862       {
75863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75864       };
75865     } catch (Dali::DaliException e) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75868       };
75869     } catch (...) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75872       };
75873     }
75874   }
75875
75876   jresult = result;
75877   return jresult;
75878 }
75879
75880
75881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75882   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75883   Dali::Actor *arg2 = 0 ;
75884   int arg3 ;
75885   Dali::Vector3 *arg4 = 0 ;
75886   Dali::Actor *arg5 = 0 ;
75887
75888   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75889   arg2 = (Dali::Actor *)jarg2;
75890   if (!arg2) {
75891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75892     return ;
75893   }
75894   arg3 = (int)jarg3;
75895   arg4 = (Dali::Vector3 *)jarg4;
75896   if (!arg4) {
75897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75898     return ;
75899   }
75900   arg5 = (Dali::Actor *)jarg5;
75901   if (!arg5) {
75902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75903     return ;
75904   }
75905   {
75906     try {
75907       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75908     } catch (std::out_of_range& e) {
75909       {
75910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75911       };
75912     } catch (std::exception& e) {
75913       {
75914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75915       };
75916     } catch (Dali::DaliException e) {
75917       {
75918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75919       };
75920     } catch (...) {
75921       {
75922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75923       };
75924     }
75925   }
75926
75927 }
75928
75929
75930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75931   void * jresult ;
75932   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75933   int arg2 ;
75934   float arg3 ;
75935   Dali::Vector3 *arg4 = 0 ;
75936   Dali::Vector3 result;
75937
75938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75939   arg2 = (int)jarg2;
75940   arg3 = (float)jarg3;
75941   arg4 = (Dali::Vector3 *)jarg4;
75942   if (!arg4) {
75943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75944     return 0;
75945   }
75946   {
75947     try {
75948       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75949     } catch (std::out_of_range& e) {
75950       {
75951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75952       };
75953     } catch (std::exception& e) {
75954       {
75955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75956       };
75957     } catch (Dali::DaliException e) {
75958       {
75959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75960       };
75961     } catch (...) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75964       };
75965     }
75966   }
75967
75968   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75969   return jresult;
75970 }
75971
75972
75973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75974   void * jresult ;
75975   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75976   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75977
75978   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75979   {
75980     try {
75981       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75982     } catch (std::out_of_range& e) {
75983       {
75984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75985       };
75986     } catch (std::exception& e) {
75987       {
75988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75989       };
75990     } catch (Dali::DaliException e) {
75991       {
75992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75993       };
75994     } catch (...) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75997       };
75998     }
75999   }
76000
76001   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76002   return jresult;
76003 }
76004
76005
76006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
76007   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76008
76009   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76010   {
76011     try {
76012       delete arg1;
76013     } catch (std::out_of_range& e) {
76014       {
76015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76016       };
76017     } catch (std::exception& e) {
76018       {
76019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76020       };
76021     } catch (Dali::DaliException e) {
76022       {
76023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76024       };
76025     } catch (...) {
76026       {
76027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76028       };
76029     }
76030   }
76031
76032 }
76033
76034
76035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
76036   unsigned int jresult ;
76037   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76038   unsigned int result;
76039
76040   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76041   {
76042     try {
76043       result = (unsigned int)(arg1)->GetNumberOfItems();
76044     } catch (std::out_of_range& e) {
76045       {
76046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76047       };
76048     } catch (std::exception& e) {
76049       {
76050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76051       };
76052     } catch (Dali::DaliException e) {
76053       {
76054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76055       };
76056     } catch (...) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76059       };
76060     }
76061   }
76062
76063   jresult = result;
76064   return jresult;
76065 }
76066
76067
76068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
76069   void * jresult ;
76070   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76071   unsigned int arg2 ;
76072   Dali::Actor result;
76073
76074   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76075   arg2 = (unsigned int)jarg2;
76076   {
76077     try {
76078       result = (arg1)->NewItem(arg2);
76079     } catch (std::out_of_range& e) {
76080       {
76081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76082       };
76083     } catch (std::exception& e) {
76084       {
76085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76086       };
76087     } catch (Dali::DaliException e) {
76088       {
76089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76090       };
76091     } catch (...) {
76092       {
76093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76094       };
76095     }
76096   }
76097
76098   jresult = new Dali::Actor((const Dali::Actor &)result);
76099   return jresult;
76100 }
76101
76102
76103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
76104   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76105   unsigned int arg2 ;
76106   Dali::Actor arg3 ;
76107   Dali::Actor *argp3 ;
76108
76109   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76110   arg2 = (unsigned int)jarg2;
76111   argp3 = (Dali::Actor *)jarg3;
76112   if (!argp3) {
76113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76114     return ;
76115   }
76116   arg3 = *argp3;
76117   {
76118     try {
76119       (arg1)->ItemReleased(arg2,arg3);
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76135       };
76136     }
76137   }
76138
76139 }
76140
76141
76142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
76143   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
76144   unsigned int arg2 ;
76145   Dali::Actor arg3 ;
76146   Dali::Actor *argp3 ;
76147
76148   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76149   arg2 = (unsigned int)jarg2;
76150   argp3 = (Dali::Actor *)jarg3;
76151   if (!argp3) {
76152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76153     return ;
76154   }
76155   arg3 = *argp3;
76156   {
76157     try {
76158       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
76159     } catch (std::out_of_range& e) {
76160       {
76161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76162       };
76163     } catch (std::exception& e) {
76164       {
76165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76166       };
76167     } catch (Dali::DaliException e) {
76168       {
76169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76170       };
76171     } catch (...) {
76172       {
76173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76174       };
76175     }
76176   }
76177
76178 }
76179
76180
76181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
76182   void * jresult ;
76183   Dali::Toolkit::ItemFactory *result = 0 ;
76184
76185   {
76186     try {
76187       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
76188     } catch (std::out_of_range& e) {
76189       {
76190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76191       };
76192     } catch (std::exception& e) {
76193       {
76194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76195       };
76196     } catch (Dali::DaliException e) {
76197       {
76198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76199       };
76200     } catch (...) {
76201       {
76202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76203       };
76204     }
76205   }
76206
76207   jresult = (void *)result;
76208   return jresult;
76209 }
76210
76211
76212 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) {
76213   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
76214   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
76215   if (director) {
76216     director->swig_connect_director(callback0, callback1, callback2);
76217   }
76218 }
76219
76220
76221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
76222   int jresult ;
76223   int result;
76224
76225   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
76226   jresult = (int)result;
76227   return jresult;
76228 }
76229
76230
76231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
76232   int jresult ;
76233   int result;
76234
76235   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
76236   jresult = (int)result;
76237   return jresult;
76238 }
76239
76240
76241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
76242   int jresult ;
76243   int result;
76244
76245   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
76246   jresult = (int)result;
76247   return jresult;
76248 }
76249
76250
76251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
76252   int jresult ;
76253   int result;
76254
76255   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
76256   jresult = (int)result;
76257   return jresult;
76258 }
76259
76260
76261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
76262   int jresult ;
76263   int result;
76264
76265   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
76266   jresult = (int)result;
76267   return jresult;
76268 }
76269
76270
76271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
76272   int jresult ;
76273   int result;
76274
76275   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
76276   jresult = (int)result;
76277   return jresult;
76278 }
76279
76280
76281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
76282   int jresult ;
76283   int result;
76284
76285   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
76286   jresult = (int)result;
76287   return jresult;
76288 }
76289
76290
76291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
76292   int jresult ;
76293   int result;
76294
76295   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
76296   jresult = (int)result;
76297   return jresult;
76298 }
76299
76300
76301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
76302   int jresult ;
76303   int result;
76304
76305   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
76306   jresult = (int)result;
76307   return jresult;
76308 }
76309
76310
76311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
76312   int jresult ;
76313   int result;
76314
76315   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
76316   jresult = (int)result;
76317   return jresult;
76318 }
76319
76320
76321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
76322   int jresult ;
76323   int result;
76324
76325   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
76326   jresult = (int)result;
76327   return jresult;
76328 }
76329
76330
76331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
76332   void * jresult ;
76333   Dali::Toolkit::ItemView::Property *result = 0 ;
76334
76335   {
76336     try {
76337       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
76338     } catch (std::out_of_range& e) {
76339       {
76340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76341       };
76342     } catch (std::exception& e) {
76343       {
76344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76345       };
76346     } catch (Dali::DaliException e) {
76347       {
76348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76349       };
76350     } catch (...) {
76351       {
76352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76353       };
76354     }
76355   }
76356
76357   jresult = (void *)result;
76358   return jresult;
76359 }
76360
76361
76362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
76363   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
76364
76365   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
76366   {
76367     try {
76368       delete arg1;
76369     } catch (std::out_of_range& e) {
76370       {
76371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76372       };
76373     } catch (std::exception& e) {
76374       {
76375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76376       };
76377     } catch (Dali::DaliException e) {
76378       {
76379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76380       };
76381     } catch (...) {
76382       {
76383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76384       };
76385     }
76386   }
76387
76388 }
76389
76390
76391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
76392   void * jresult ;
76393   Dali::Toolkit::ItemView *result = 0 ;
76394
76395   {
76396     try {
76397       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
76398     } catch (std::out_of_range& e) {
76399       {
76400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76401       };
76402     } catch (std::exception& e) {
76403       {
76404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76405       };
76406     } catch (Dali::DaliException e) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76409       };
76410     } catch (...) {
76411       {
76412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76413       };
76414     }
76415   }
76416
76417   jresult = (void *)result;
76418   return jresult;
76419 }
76420
76421
76422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
76423   void * jresult ;
76424   Dali::Toolkit::ItemView *arg1 = 0 ;
76425   Dali::Toolkit::ItemView *result = 0 ;
76426
76427   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76428   if (!arg1) {
76429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76430     return 0;
76431   }
76432   {
76433     try {
76434       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
76435     } catch (std::out_of_range& e) {
76436       {
76437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76438       };
76439     } catch (std::exception& e) {
76440       {
76441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76442       };
76443     } catch (Dali::DaliException e) {
76444       {
76445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76446       };
76447     } catch (...) {
76448       {
76449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76450       };
76451     }
76452   }
76453
76454   jresult = (void *)result;
76455   return jresult;
76456 }
76457
76458
76459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
76460   void * jresult ;
76461   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76462   Dali::Toolkit::ItemView *arg2 = 0 ;
76463   Dali::Toolkit::ItemView *result = 0 ;
76464
76465   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76466   arg2 = (Dali::Toolkit::ItemView *)jarg2;
76467   if (!arg2) {
76468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
76469     return 0;
76470   }
76471   {
76472     try {
76473       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
76474     } catch (std::out_of_range& e) {
76475       {
76476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76477       };
76478     } catch (std::exception& e) {
76479       {
76480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76481       };
76482     } catch (Dali::DaliException e) {
76483       {
76484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76485       };
76486     } catch (...) {
76487       {
76488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76489       };
76490     }
76491   }
76492
76493   jresult = (void *)result;
76494   return jresult;
76495 }
76496
76497
76498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
76499   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76500
76501   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76502   {
76503     try {
76504       delete arg1;
76505     } catch (std::out_of_range& e) {
76506       {
76507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76508       };
76509     } catch (std::exception& e) {
76510       {
76511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76512       };
76513     } catch (Dali::DaliException e) {
76514       {
76515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76516       };
76517     } catch (...) {
76518       {
76519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76520       };
76521     }
76522   }
76523
76524 }
76525
76526
76527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
76528   void * jresult ;
76529   Dali::Toolkit::ItemFactory *arg1 = 0 ;
76530   Dali::Toolkit::ItemView result;
76531
76532   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
76533   if (!arg1) {
76534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
76535     return 0;
76536   }
76537   {
76538     try {
76539       result = Dali::Toolkit::ItemView::New(*arg1);
76540     } catch (std::out_of_range& e) {
76541       {
76542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76543       };
76544     } catch (std::exception& e) {
76545       {
76546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76547       };
76548     } catch (Dali::DaliException e) {
76549       {
76550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76551       };
76552     } catch (...) {
76553       {
76554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76555       };
76556     }
76557   }
76558
76559   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76560   return jresult;
76561 }
76562
76563
76564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
76565   void * jresult ;
76566   Dali::BaseHandle arg1 ;
76567   Dali::BaseHandle *argp1 ;
76568   Dali::Toolkit::ItemView result;
76569
76570   argp1 = (Dali::BaseHandle *)jarg1;
76571   if (!argp1) {
76572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
76573     return 0;
76574   }
76575   arg1 = *argp1;
76576   {
76577     try {
76578       result = Dali::Toolkit::ItemView::DownCast(arg1);
76579     } catch (std::out_of_range& e) {
76580       {
76581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76582       };
76583     } catch (std::exception& e) {
76584       {
76585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76586       };
76587     } catch (Dali::DaliException e) {
76588       {
76589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76590       };
76591     } catch (...) {
76592       {
76593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76594       };
76595     }
76596   }
76597
76598   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
76599   return jresult;
76600 }
76601
76602
76603 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
76604   unsigned int jresult ;
76605   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76606   unsigned int result;
76607
76608   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76609   {
76610     try {
76611       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
76612     } catch (std::out_of_range& e) {
76613       {
76614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76615       };
76616     } catch (std::exception& e) {
76617       {
76618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76619       };
76620     } catch (Dali::DaliException e) {
76621       {
76622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76623       };
76624     } catch (...) {
76625       {
76626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76627       };
76628     }
76629   }
76630
76631   jresult = result;
76632   return jresult;
76633 }
76634
76635
76636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
76637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76638   Dali::Toolkit::ItemLayout *arg2 = 0 ;
76639
76640   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76641   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
76642   if (!arg2) {
76643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
76644     return ;
76645   }
76646   {
76647     try {
76648       (arg1)->AddLayout(*arg2);
76649     } catch (std::out_of_range& e) {
76650       {
76651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76652       };
76653     } catch (std::exception& e) {
76654       {
76655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76656       };
76657     } catch (Dali::DaliException e) {
76658       {
76659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76660       };
76661     } catch (...) {
76662       {
76663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76664       };
76665     }
76666   }
76667
76668 }
76669
76670
76671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
76672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76673   unsigned int arg2 ;
76674
76675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76676   arg2 = (unsigned int)jarg2;
76677   {
76678     try {
76679       (arg1)->RemoveLayout(arg2);
76680     } catch (std::out_of_range& e) {
76681       {
76682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76683       };
76684     } catch (std::exception& e) {
76685       {
76686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76687       };
76688     } catch (Dali::DaliException e) {
76689       {
76690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76691       };
76692     } catch (...) {
76693       {
76694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76695       };
76696     }
76697   }
76698
76699 }
76700
76701
76702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
76703   void * jresult ;
76704   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76705   unsigned int arg2 ;
76706   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76707
76708   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76709   arg2 = (unsigned int)jarg2;
76710   {
76711     try {
76712       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
76713     } catch (std::out_of_range& e) {
76714       {
76715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76716       };
76717     } catch (std::exception& e) {
76718       {
76719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76720       };
76721     } catch (Dali::DaliException e) {
76722       {
76723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76724       };
76725     } catch (...) {
76726       {
76727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76728       };
76729     }
76730   }
76731
76732   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76733   return jresult;
76734 }
76735
76736
76737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
76738   void * jresult ;
76739   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76740   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
76741
76742   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76743   {
76744     try {
76745       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
76746     } catch (std::out_of_range& e) {
76747       {
76748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76749       };
76750     } catch (std::exception& e) {
76751       {
76752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76753       };
76754     } catch (Dali::DaliException e) {
76755       {
76756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76757       };
76758     } catch (...) {
76759       {
76760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76761       };
76762     }
76763   }
76764
76765   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76766   return jresult;
76767 }
76768
76769
76770 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76771   float jresult ;
76772   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76773   Dali::Toolkit::ItemId arg2 ;
76774   float result;
76775
76776   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76777   arg2 = (Dali::Toolkit::ItemId)jarg2;
76778   {
76779     try {
76780       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76781     } catch (std::out_of_range& e) {
76782       {
76783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76784       };
76785     } catch (std::exception& e) {
76786       {
76787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76788       };
76789     } catch (Dali::DaliException e) {
76790       {
76791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76792       };
76793     } catch (...) {
76794       {
76795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76796       };
76797     }
76798   }
76799
76800   jresult = result;
76801   return jresult;
76802 }
76803
76804
76805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76806   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76807   unsigned int arg2 ;
76808   Dali::Vector3 arg3 ;
76809   float arg4 ;
76810   Dali::Vector3 *argp3 ;
76811
76812   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76813   arg2 = (unsigned int)jarg2;
76814   argp3 = (Dali::Vector3 *)jarg3;
76815   if (!argp3) {
76816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76817     return ;
76818   }
76819   arg3 = *argp3;
76820   arg4 = (float)jarg4;
76821   {
76822     try {
76823       (arg1)->ActivateLayout(arg2,arg3,arg4);
76824     } catch (std::out_of_range& e) {
76825       {
76826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76827       };
76828     } catch (std::exception& e) {
76829       {
76830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76831       };
76832     } catch (Dali::DaliException e) {
76833       {
76834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76835       };
76836     } catch (...) {
76837       {
76838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76839       };
76840     }
76841   }
76842
76843 }
76844
76845
76846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76847   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76848
76849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76850   {
76851     try {
76852       (arg1)->DeactivateCurrentLayout();
76853     } catch (std::out_of_range& e) {
76854       {
76855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76856       };
76857     } catch (std::exception& e) {
76858       {
76859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76860       };
76861     } catch (Dali::DaliException e) {
76862       {
76863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76864       };
76865     } catch (...) {
76866       {
76867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76868       };
76869     }
76870   }
76871
76872 }
76873
76874
76875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76876   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76877   float arg2 ;
76878
76879   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76880   arg2 = (float)jarg2;
76881   {
76882     try {
76883       (arg1)->SetMinimumSwipeSpeed(arg2);
76884     } catch (std::out_of_range& e) {
76885       {
76886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76887       };
76888     } catch (std::exception& e) {
76889       {
76890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76891       };
76892     } catch (Dali::DaliException e) {
76893       {
76894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76895       };
76896     } catch (...) {
76897       {
76898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76899       };
76900     }
76901   }
76902
76903 }
76904
76905
76906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76907   float jresult ;
76908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76909   float result;
76910
76911   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76912   {
76913     try {
76914       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76915     } catch (std::out_of_range& e) {
76916       {
76917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76918       };
76919     } catch (std::exception& e) {
76920       {
76921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76922       };
76923     } catch (Dali::DaliException e) {
76924       {
76925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76926       };
76927     } catch (...) {
76928       {
76929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76930       };
76931     }
76932   }
76933
76934   jresult = result;
76935   return jresult;
76936 }
76937
76938
76939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   float arg2 ;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   arg2 = (float)jarg2;
76945   {
76946     try {
76947       (arg1)->SetMinimumSwipeDistance(arg2);
76948     } catch (std::out_of_range& e) {
76949       {
76950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76951       };
76952     } catch (std::exception& e) {
76953       {
76954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76955       };
76956     } catch (Dali::DaliException e) {
76957       {
76958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76959       };
76960     } catch (...) {
76961       {
76962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76963       };
76964     }
76965   }
76966
76967 }
76968
76969
76970 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76971   float jresult ;
76972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76973   float result;
76974
76975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76976   {
76977     try {
76978       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76979     } catch (std::out_of_range& e) {
76980       {
76981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76982       };
76983     } catch (std::exception& e) {
76984       {
76985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76986       };
76987     } catch (Dali::DaliException e) {
76988       {
76989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76990       };
76991     } catch (...) {
76992       {
76993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76994       };
76995     }
76996   }
76997
76998   jresult = result;
76999   return jresult;
77000 }
77001
77002
77003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
77004   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77005   float arg2 ;
77006
77007   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77008   arg2 = (float)jarg2;
77009   {
77010     try {
77011       (arg1)->SetWheelScrollDistanceStep(arg2);
77012     } catch (std::out_of_range& e) {
77013       {
77014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77015       };
77016     } catch (std::exception& e) {
77017       {
77018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77019       };
77020     } catch (Dali::DaliException e) {
77021       {
77022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77023       };
77024     } catch (...) {
77025       {
77026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77027       };
77028     }
77029   }
77030
77031 }
77032
77033
77034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
77035   float jresult ;
77036   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77037   float result;
77038
77039   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77040   {
77041     try {
77042       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
77043     } catch (std::out_of_range& e) {
77044       {
77045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77046       };
77047     } catch (std::exception& e) {
77048       {
77049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77050       };
77051     } catch (Dali::DaliException e) {
77052       {
77053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77054       };
77055     } catch (...) {
77056       {
77057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77058       };
77059     }
77060   }
77061
77062   jresult = result;
77063   return jresult;
77064 }
77065
77066
77067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
77068   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77069   bool arg2 ;
77070
77071   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77072   arg2 = jarg2 ? true : false;
77073   {
77074     try {
77075       (arg1)->SetAnchoring(arg2);
77076     } catch (std::out_of_range& e) {
77077       {
77078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77079       };
77080     } catch (std::exception& e) {
77081       {
77082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77083       };
77084     } catch (Dali::DaliException e) {
77085       {
77086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77087       };
77088     } catch (...) {
77089       {
77090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77091       };
77092     }
77093   }
77094
77095 }
77096
77097 //// ========================= end of part 3 =============================
77098
77099 //// ========================== start part 4 ===============================
77100
77101
77102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
77103   unsigned int jresult ;
77104   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77105   bool result;
77106
77107   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77108   {
77109     try {
77110       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
77111     } catch (std::out_of_range& e) {
77112       {
77113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77114       };
77115     } catch (std::exception& e) {
77116       {
77117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77118       };
77119     } catch (Dali::DaliException e) {
77120       {
77121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77122       };
77123     } catch (...) {
77124       {
77125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77126       };
77127     }
77128   }
77129
77130   jresult = result;
77131   return jresult;
77132 }
77133
77134
77135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
77136   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77137   float arg2 ;
77138
77139   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77140   arg2 = (float)jarg2;
77141   {
77142     try {
77143       (arg1)->SetAnchoringDuration(arg2);
77144     } catch (std::out_of_range& e) {
77145       {
77146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77147       };
77148     } catch (std::exception& e) {
77149       {
77150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77151       };
77152     } catch (Dali::DaliException e) {
77153       {
77154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77155       };
77156     } catch (...) {
77157       {
77158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77159       };
77160     }
77161   }
77162
77163 }
77164
77165
77166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
77167   float jresult ;
77168   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77169   float result;
77170
77171   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77172   {
77173     try {
77174       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
77175     } catch (std::out_of_range& e) {
77176       {
77177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77178       };
77179     } catch (std::exception& e) {
77180       {
77181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77182       };
77183     } catch (Dali::DaliException e) {
77184       {
77185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77186       };
77187     } catch (...) {
77188       {
77189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77190       };
77191     }
77192   }
77193
77194   jresult = result;
77195   return jresult;
77196 }
77197
77198
77199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
77200   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77201   Dali::Toolkit::ItemId arg2 ;
77202   float arg3 ;
77203
77204   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77205   arg2 = (Dali::Toolkit::ItemId)jarg2;
77206   arg3 = (float)jarg3;
77207   {
77208     try {
77209       (arg1)->ScrollToItem(arg2,arg3);
77210     } catch (std::out_of_range& e) {
77211       {
77212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77213       };
77214     } catch (std::exception& e) {
77215       {
77216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77217       };
77218     } catch (Dali::DaliException e) {
77219       {
77220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77221       };
77222     } catch (...) {
77223       {
77224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77225       };
77226     }
77227   }
77228
77229 }
77230
77231
77232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
77233   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77234   float arg2 ;
77235
77236   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77237   arg2 = (float)jarg2;
77238   {
77239     try {
77240       (arg1)->SetRefreshInterval(arg2);
77241     } catch (std::out_of_range& e) {
77242       {
77243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77244       };
77245     } catch (std::exception& e) {
77246       {
77247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77248       };
77249     } catch (Dali::DaliException e) {
77250       {
77251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77252       };
77253     } catch (...) {
77254       {
77255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77256       };
77257     }
77258   }
77259
77260 }
77261
77262
77263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
77264   float jresult ;
77265   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77266   float result;
77267
77268   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77269   {
77270     try {
77271       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
77272     } catch (std::out_of_range& e) {
77273       {
77274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77275       };
77276     } catch (std::exception& e) {
77277       {
77278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77279       };
77280     } catch (Dali::DaliException e) {
77281       {
77282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77283       };
77284     } catch (...) {
77285       {
77286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77287       };
77288     }
77289   }
77290
77291   jresult = result;
77292   return jresult;
77293 }
77294
77295
77296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
77297   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77298
77299   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77300   {
77301     try {
77302       (arg1)->Refresh();
77303     } catch (std::out_of_range& e) {
77304       {
77305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77306       };
77307     } catch (std::exception& e) {
77308       {
77309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77310       };
77311     } catch (Dali::DaliException e) {
77312       {
77313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77314       };
77315     } catch (...) {
77316       {
77317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77318       };
77319     }
77320   }
77321
77322 }
77323
77324
77325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
77326   void * jresult ;
77327   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77328   Dali::Toolkit::ItemId arg2 ;
77329   Dali::Actor result;
77330
77331   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77332   arg2 = (Dali::Toolkit::ItemId)jarg2;
77333   {
77334     try {
77335       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
77336     } catch (std::out_of_range& e) {
77337       {
77338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77339       };
77340     } catch (std::exception& e) {
77341       {
77342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77343       };
77344     } catch (Dali::DaliException e) {
77345       {
77346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77347       };
77348     } catch (...) {
77349       {
77350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77351       };
77352     }
77353   }
77354
77355   jresult = new Dali::Actor((const Dali::Actor &)result);
77356   return jresult;
77357 }
77358
77359
77360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
77361   unsigned int jresult ;
77362   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77363   Dali::Actor arg2 ;
77364   Dali::Actor *argp2 ;
77365   Dali::Toolkit::ItemId result;
77366
77367   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77368   argp2 = (Dali::Actor *)jarg2;
77369   if (!argp2) {
77370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77371     return 0;
77372   }
77373   arg2 = *argp2;
77374   {
77375     try {
77376       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
77377     } catch (std::out_of_range& e) {
77378       {
77379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77380       };
77381     } catch (std::exception& e) {
77382       {
77383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77384       };
77385     } catch (Dali::DaliException e) {
77386       {
77387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77388       };
77389     } catch (...) {
77390       {
77391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77392       };
77393     }
77394   }
77395
77396   jresult = result;
77397   return jresult;
77398 }
77399
77400
77401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
77402   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77403   Dali::Toolkit::Item arg2 ;
77404   float arg3 ;
77405   Dali::Toolkit::Item *argp2 ;
77406
77407   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77408   argp2 = (Dali::Toolkit::Item *)jarg2;
77409   if (!argp2) {
77410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77411     return ;
77412   }
77413   arg2 = *argp2;
77414   arg3 = (float)jarg3;
77415   {
77416     try {
77417       (arg1)->InsertItem(arg2,arg3);
77418     } catch (std::out_of_range& e) {
77419       {
77420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77421       };
77422     } catch (std::exception& e) {
77423       {
77424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77425       };
77426     } catch (Dali::DaliException e) {
77427       {
77428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77429       };
77430     } catch (...) {
77431       {
77432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77433       };
77434     }
77435   }
77436
77437 }
77438
77439
77440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
77441   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77442   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77443   float arg3 ;
77444
77445   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77446   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77447   if (!arg2) {
77448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77449     return ;
77450   }
77451   arg3 = (float)jarg3;
77452   {
77453     try {
77454       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77455     } catch (std::out_of_range& e) {
77456       {
77457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77458       };
77459     } catch (std::exception& e) {
77460       {
77461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77462       };
77463     } catch (Dali::DaliException e) {
77464       {
77465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77466       };
77467     } catch (...) {
77468       {
77469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77470       };
77471     }
77472   }
77473
77474 }
77475
77476
77477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
77478   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77479   Dali::Toolkit::ItemId arg2 ;
77480   float arg3 ;
77481
77482   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77483   arg2 = (Dali::Toolkit::ItemId)jarg2;
77484   arg3 = (float)jarg3;
77485   {
77486     try {
77487       (arg1)->RemoveItem(arg2,arg3);
77488     } catch (std::out_of_range& e) {
77489       {
77490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77491       };
77492     } catch (std::exception& e) {
77493       {
77494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77495       };
77496     } catch (Dali::DaliException e) {
77497       {
77498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77499       };
77500     } catch (...) {
77501       {
77502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77503       };
77504     }
77505   }
77506
77507 }
77508
77509
77510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
77511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77512   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
77513   float arg3 ;
77514
77515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77516   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
77517   if (!arg2) {
77518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
77519     return ;
77520   }
77521   arg3 = (float)jarg3;
77522   {
77523     try {
77524       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
77525     } catch (std::out_of_range& e) {
77526       {
77527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77528       };
77529     } catch (std::exception& e) {
77530       {
77531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77532       };
77533     } catch (Dali::DaliException e) {
77534       {
77535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77536       };
77537     } catch (...) {
77538       {
77539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77540       };
77541     }
77542   }
77543
77544 }
77545
77546
77547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
77548   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77549   Dali::Toolkit::Item arg2 ;
77550   float arg3 ;
77551   Dali::Toolkit::Item *argp2 ;
77552
77553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77554   argp2 = (Dali::Toolkit::Item *)jarg2;
77555   if (!argp2) {
77556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
77557     return ;
77558   }
77559   arg2 = *argp2;
77560   arg3 = (float)jarg3;
77561   {
77562     try {
77563       (arg1)->ReplaceItem(arg2,arg3);
77564     } catch (std::out_of_range& e) {
77565       {
77566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77567       };
77568     } catch (std::exception& e) {
77569       {
77570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77571       };
77572     } catch (Dali::DaliException e) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77575       };
77576     } catch (...) {
77577       {
77578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77579       };
77580     }
77581   }
77582
77583 }
77584
77585
77586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
77587   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77588   Dali::Toolkit::ItemContainer *arg2 = 0 ;
77589   float arg3 ;
77590
77591   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77592   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
77593   if (!arg2) {
77594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
77595     return ;
77596   }
77597   arg3 = (float)jarg3;
77598   {
77599     try {
77600       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
77601     } catch (std::out_of_range& e) {
77602       {
77603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77604       };
77605     } catch (std::exception& e) {
77606       {
77607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77608       };
77609     } catch (Dali::DaliException e) {
77610       {
77611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77612       };
77613     } catch (...) {
77614       {
77615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77616       };
77617     }
77618   }
77619
77620 }
77621
77622
77623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
77624   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77625   Dali::Vector3 *arg2 = 0 ;
77626
77627   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77628   arg2 = (Dali::Vector3 *)jarg2;
77629   if (!arg2) {
77630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77631     return ;
77632   }
77633   {
77634     try {
77635       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
77636     } catch (std::out_of_range& e) {
77637       {
77638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77639       };
77640     } catch (std::exception& e) {
77641       {
77642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77643       };
77644     } catch (Dali::DaliException e) {
77645       {
77646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77647       };
77648     } catch (...) {
77649       {
77650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77651       };
77652     }
77653   }
77654
77655 }
77656
77657
77658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
77659   void * jresult ;
77660   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77661   Dali::Vector3 result;
77662
77663   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77664   {
77665     try {
77666       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
77667     } catch (std::out_of_range& e) {
77668       {
77669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77670       };
77671     } catch (std::exception& e) {
77672       {
77673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77674       };
77675     } catch (Dali::DaliException e) {
77676       {
77677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77678       };
77679     } catch (...) {
77680       {
77681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77682       };
77683     }
77684   }
77685
77686   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77687   return jresult;
77688 }
77689
77690
77691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
77692   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77693   Dali::Vector3 *arg2 = 0 ;
77694
77695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77696   arg2 = (Dali::Vector3 *)jarg2;
77697   if (!arg2) {
77698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77699     return ;
77700   }
77701   {
77702     try {
77703       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
77704     } catch (std::out_of_range& e) {
77705       {
77706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77707       };
77708     } catch (std::exception& e) {
77709       {
77710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77711       };
77712     } catch (Dali::DaliException e) {
77713       {
77714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77715       };
77716     } catch (...) {
77717       {
77718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77719       };
77720     }
77721   }
77722
77723 }
77724
77725
77726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
77727   void * jresult ;
77728   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77729   Dali::Vector3 result;
77730
77731   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77732   {
77733     try {
77734       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
77735     } catch (std::out_of_range& e) {
77736       {
77737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77738       };
77739     } catch (std::exception& e) {
77740       {
77741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77742       };
77743     } catch (Dali::DaliException e) {
77744       {
77745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77746       };
77747     } catch (...) {
77748       {
77749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77750       };
77751     }
77752   }
77753
77754   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77755   return jresult;
77756 }
77757
77758
77759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77761   Dali::Toolkit::ItemRange *arg2 = 0 ;
77762
77763   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77764   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77765   if (!arg2) {
77766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77767     return ;
77768   }
77769   {
77770     try {
77771       (arg1)->GetItemsRange(*arg2);
77772     } catch (std::out_of_range& e) {
77773       {
77774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77775       };
77776     } catch (std::exception& e) {
77777       {
77778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77779       };
77780     } catch (Dali::DaliException e) {
77781       {
77782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77783       };
77784     } catch (...) {
77785       {
77786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77787       };
77788     }
77789   }
77790
77791 }
77792
77793
77794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77795   void * jresult ;
77796   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77797   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77798
77799   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77800   {
77801     try {
77802       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77803     } catch (std::out_of_range& e) {
77804       {
77805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77806       };
77807     } catch (std::exception& e) {
77808       {
77809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77810       };
77811     } catch (Dali::DaliException e) {
77812       {
77813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77814       };
77815     } catch (...) {
77816       {
77817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77818       };
77819     }
77820   }
77821
77822   jresult = (void *)result;
77823   return jresult;
77824 }
77825
77826
77827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77828   Dali::Vector3 *arg1 = 0 ;
77829   PropertyInputContainer *arg2 = 0 ;
77830
77831   arg1 = (Dali::Vector3 *)jarg1;
77832   if (!arg1) {
77833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77834     return ;
77835   }
77836   arg2 = (PropertyInputContainer *)jarg2;
77837   if (!arg2) {
77838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77839     return ;
77840   }
77841   {
77842     try {
77843       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77844     } catch (std::out_of_range& e) {
77845       {
77846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77847       };
77848     } catch (std::exception& e) {
77849       {
77850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77851       };
77852     } catch (Dali::DaliException e) {
77853       {
77854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77855       };
77856     } catch (...) {
77857       {
77858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77859       };
77860     }
77861   }
77862
77863 }
77864
77865
77866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77867   Dali::Vector3 *arg1 = 0 ;
77868   PropertyInputContainer *arg2 = 0 ;
77869
77870   arg1 = (Dali::Vector3 *)jarg1;
77871   if (!arg1) {
77872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77873     return ;
77874   }
77875   arg2 = (PropertyInputContainer *)jarg2;
77876   if (!arg2) {
77877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77878     return ;
77879   }
77880   {
77881     try {
77882       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77883     } catch (std::out_of_range& e) {
77884       {
77885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77886       };
77887     } catch (std::exception& e) {
77888       {
77889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77890       };
77891     } catch (Dali::DaliException e) {
77892       {
77893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77894       };
77895     } catch (...) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77898       };
77899     }
77900   }
77901
77902 }
77903
77904
77905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77906   void * jresult ;
77907   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77908
77909   {
77910     try {
77911       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77912     } catch (std::out_of_range& e) {
77913       {
77914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77915       };
77916     } catch (std::exception& e) {
77917       {
77918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77919       };
77920     } catch (Dali::DaliException e) {
77921       {
77922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77923       };
77924     } catch (...) {
77925       {
77926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77927       };
77928     }
77929   }
77930
77931   jresult = (void *)result;
77932   return jresult;
77933 }
77934
77935
77936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77937   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77938
77939   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77940   {
77941     try {
77942       delete arg1;
77943     } catch (std::out_of_range& e) {
77944       {
77945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77946       };
77947     } catch (std::exception& e) {
77948       {
77949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77950       };
77951     } catch (Dali::DaliException e) {
77952       {
77953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77954       };
77955     } catch (...) {
77956       {
77957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77958       };
77959     }
77960   }
77961
77962 }
77963
77964
77965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77966   void * jresult ;
77967   Dali::Path arg1 ;
77968   Dali::Vector3 *arg2 = 0 ;
77969   Dali::Property::Index arg3 ;
77970   Dali::Vector3 *arg4 = 0 ;
77971   unsigned int arg5 ;
77972   Dali::Path *argp1 ;
77973   Dali::Toolkit::ScrollViewPagePathEffect result;
77974
77975   argp1 = (Dali::Path *)jarg1;
77976   if (!argp1) {
77977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77978     return 0;
77979   }
77980   arg1 = *argp1;
77981   arg2 = (Dali::Vector3 *)jarg2;
77982   if (!arg2) {
77983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77984     return 0;
77985   }
77986   arg3 = (Dali::Property::Index)jarg3;
77987   arg4 = (Dali::Vector3 *)jarg4;
77988   if (!arg4) {
77989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77990     return 0;
77991   }
77992   arg5 = (unsigned int)jarg5;
77993   {
77994     try {
77995       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77996     } catch (std::out_of_range& e) {
77997       {
77998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77999       };
78000     } catch (std::exception& e) {
78001       {
78002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78003       };
78004     } catch (Dali::DaliException e) {
78005       {
78006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78007       };
78008     } catch (...) {
78009       {
78010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78011       };
78012     }
78013   }
78014
78015   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78016   return jresult;
78017 }
78018
78019
78020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
78021   void * jresult ;
78022   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
78023
78024   {
78025     try {
78026       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
78027     } catch (std::out_of_range& e) {
78028       {
78029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78030       };
78031     } catch (std::exception& e) {
78032       {
78033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78034       };
78035     } catch (Dali::DaliException e) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78038       };
78039     } catch (...) {
78040       {
78041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78042       };
78043     }
78044   }
78045
78046   jresult = (void *)result;
78047   return jresult;
78048 }
78049
78050
78051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
78052   void * jresult ;
78053   Dali::BaseHandle arg1 ;
78054   Dali::BaseHandle *argp1 ;
78055   Dali::Toolkit::ScrollViewPagePathEffect result;
78056
78057   argp1 = (Dali::BaseHandle *)jarg1;
78058   if (!argp1) {
78059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78060     return 0;
78061   }
78062   arg1 = *argp1;
78063   {
78064     try {
78065       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
78066     } catch (std::out_of_range& e) {
78067       {
78068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78069       };
78070     } catch (std::exception& e) {
78071       {
78072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78073       };
78074     } catch (Dali::DaliException e) {
78075       {
78076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78077       };
78078     } catch (...) {
78079       {
78080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78081       };
78082     }
78083   }
78084
78085   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
78086   return jresult;
78087 }
78088
78089
78090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
78091   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78092   Dali::Actor arg2 ;
78093   unsigned int arg3 ;
78094   Dali::Actor *argp2 ;
78095
78096   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78097   argp2 = (Dali::Actor *)jarg2;
78098   if (!argp2) {
78099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78100     return ;
78101   }
78102   arg2 = *argp2;
78103   arg3 = (unsigned int)jarg3;
78104   {
78105     try {
78106       (arg1)->ApplyToPage(arg2,arg3);
78107     } catch (std::out_of_range& e) {
78108       {
78109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78110       };
78111     } catch (std::exception& e) {
78112       {
78113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78114       };
78115     } catch (Dali::DaliException e) {
78116       {
78117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78118       };
78119     } catch (...) {
78120       {
78121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78122       };
78123     }
78124   }
78125
78126 }
78127
78128
78129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
78130   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
78131
78132   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
78133   {
78134     try {
78135       delete arg1;
78136     } catch (std::out_of_range& e) {
78137       {
78138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78139       };
78140     } catch (std::exception& e) {
78141       {
78142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78143       };
78144     } catch (Dali::DaliException e) {
78145       {
78146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78147       };
78148     } catch (...) {
78149       {
78150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78151       };
78152     }
78153   }
78154
78155 }
78156
78157
78158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
78159   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78160   Dali::Toolkit::ClampState arg2 ;
78161
78162   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78163   arg2 = (Dali::Toolkit::ClampState)jarg2;
78164   if (arg1) (arg1)->x = arg2;
78165 }
78166
78167
78168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
78169   int jresult ;
78170   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78171   Dali::Toolkit::ClampState result;
78172
78173   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78174   result = (Dali::Toolkit::ClampState) ((arg1)->x);
78175   jresult = (int)result;
78176   return jresult;
78177 }
78178
78179
78180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
78181   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78182   Dali::Toolkit::ClampState arg2 ;
78183
78184   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78185   arg2 = (Dali::Toolkit::ClampState)jarg2;
78186   if (arg1) (arg1)->y = arg2;
78187 }
78188
78189
78190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
78191   int jresult ;
78192   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78193   Dali::Toolkit::ClampState result;
78194
78195   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78196   result = (Dali::Toolkit::ClampState) ((arg1)->y);
78197   jresult = (int)result;
78198   return jresult;
78199 }
78200
78201
78202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
78203   void * jresult ;
78204   Dali::Toolkit::ClampState2D *result = 0 ;
78205
78206   {
78207     try {
78208       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
78209     } catch (std::out_of_range& e) {
78210       {
78211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78212       };
78213     } catch (std::exception& e) {
78214       {
78215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78216       };
78217     } catch (Dali::DaliException e) {
78218       {
78219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78220       };
78221     } catch (...) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78224       };
78225     }
78226   }
78227
78228   jresult = (void *)result;
78229   return jresult;
78230 }
78231
78232
78233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
78234   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
78235
78236   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
78237   {
78238     try {
78239       delete arg1;
78240     } catch (std::out_of_range& e) {
78241       {
78242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78243       };
78244     } catch (std::exception& e) {
78245       {
78246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78247       };
78248     } catch (Dali::DaliException e) {
78249       {
78250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78251       };
78252     } catch (...) {
78253       {
78254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78255       };
78256     }
78257   }
78258
78259 }
78260
78261
78262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
78263   void * jresult ;
78264   float arg1 ;
78265   float arg2 ;
78266   bool arg3 ;
78267   Dali::Toolkit::RulerDomain *result = 0 ;
78268
78269   arg1 = (float)jarg1;
78270   arg2 = (float)jarg2;
78271   arg3 = jarg3 ? true : false;
78272   {
78273     try {
78274       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
78275     } catch (std::out_of_range& e) {
78276       {
78277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78278       };
78279     } catch (std::exception& e) {
78280       {
78281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78282       };
78283     } catch (Dali::DaliException e) {
78284       {
78285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78286       };
78287     } catch (...) {
78288       {
78289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78290       };
78291     }
78292   }
78293
78294   jresult = (void *)result;
78295   return jresult;
78296 }
78297
78298
78299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
78300   void * jresult ;
78301   float arg1 ;
78302   float arg2 ;
78303   Dali::Toolkit::RulerDomain *result = 0 ;
78304
78305   arg1 = (float)jarg1;
78306   arg2 = (float)jarg2;
78307   {
78308     try {
78309       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
78310     } catch (std::out_of_range& e) {
78311       {
78312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78313       };
78314     } catch (std::exception& e) {
78315       {
78316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78317       };
78318     } catch (Dali::DaliException e) {
78319       {
78320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78321       };
78322     } catch (...) {
78323       {
78324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78325       };
78326     }
78327   }
78328
78329   jresult = (void *)result;
78330   return jresult;
78331 }
78332
78333
78334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
78335   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78336   float arg2 ;
78337
78338   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78339   arg2 = (float)jarg2;
78340   if (arg1) (arg1)->min = arg2;
78341 }
78342
78343
78344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
78345   float jresult ;
78346   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78347   float result;
78348
78349   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78350   result = (float) ((arg1)->min);
78351   jresult = result;
78352   return jresult;
78353 }
78354
78355
78356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
78357   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78358   float arg2 ;
78359
78360   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78361   arg2 = (float)jarg2;
78362   if (arg1) (arg1)->max = arg2;
78363 }
78364
78365
78366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
78367   float jresult ;
78368   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78369   float result;
78370
78371   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78372   result = (float) ((arg1)->max);
78373   jresult = result;
78374   return jresult;
78375 }
78376
78377
78378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
78379   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78380   bool arg2 ;
78381
78382   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78383   arg2 = jarg2 ? true : false;
78384   if (arg1) (arg1)->enabled = arg2;
78385 }
78386
78387
78388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
78389   unsigned int jresult ;
78390   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78391   bool result;
78392
78393   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78394   result = (bool) ((arg1)->enabled);
78395   jresult = result;
78396   return jresult;
78397 }
78398
78399
78400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78401   float jresult ;
78402   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78403   float arg2 ;
78404   float arg3 ;
78405   float arg4 ;
78406   float result;
78407
78408   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78409   arg2 = (float)jarg2;
78410   arg3 = (float)jarg3;
78411   arg4 = (float)jarg4;
78412   {
78413     try {
78414       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
78415     } catch (std::out_of_range& e) {
78416       {
78417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78418       };
78419     } catch (std::exception& e) {
78420       {
78421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78422       };
78423     } catch (Dali::DaliException e) {
78424       {
78425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78426       };
78427     } catch (...) {
78428       {
78429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78430       };
78431     }
78432   }
78433
78434   jresult = result;
78435   return jresult;
78436 }
78437
78438
78439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78440   float jresult ;
78441   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78442   float arg2 ;
78443   float arg3 ;
78444   float result;
78445
78446   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78447   arg2 = (float)jarg2;
78448   arg3 = (float)jarg3;
78449   {
78450     try {
78451       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
78452     } catch (std::out_of_range& e) {
78453       {
78454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78455       };
78456     } catch (std::exception& e) {
78457       {
78458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78459       };
78460     } catch (Dali::DaliException e) {
78461       {
78462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78463       };
78464     } catch (...) {
78465       {
78466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78467       };
78468     }
78469   }
78470
78471   jresult = result;
78472   return jresult;
78473 }
78474
78475
78476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
78477   float jresult ;
78478   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78479   float arg2 ;
78480   float result;
78481
78482   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78483   arg2 = (float)jarg2;
78484   {
78485     try {
78486       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
78487     } catch (std::out_of_range& e) {
78488       {
78489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78490       };
78491     } catch (std::exception& e) {
78492       {
78493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78494       };
78495     } catch (Dali::DaliException e) {
78496       {
78497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78498       };
78499     } catch (...) {
78500       {
78501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78502       };
78503     }
78504   }
78505
78506   jresult = result;
78507   return jresult;
78508 }
78509
78510
78511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78512   float jresult ;
78513   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78514   float arg2 ;
78515   float arg3 ;
78516   float arg4 ;
78517   Dali::Toolkit::ClampState *arg5 = 0 ;
78518   float result;
78519
78520   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78521   arg2 = (float)jarg2;
78522   arg3 = (float)jarg3;
78523   arg4 = (float)jarg4;
78524   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78525   if (!arg5) {
78526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78527     return 0;
78528   }
78529   {
78530     try {
78531       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78532     } catch (std::out_of_range& e) {
78533       {
78534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78535       };
78536     } catch (std::exception& e) {
78537       {
78538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78539       };
78540     } catch (Dali::DaliException e) {
78541       {
78542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78543       };
78544     } catch (...) {
78545       {
78546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78547       };
78548     }
78549   }
78550
78551   jresult = result;
78552   return jresult;
78553 }
78554
78555
78556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
78557   float jresult ;
78558   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78559   float result;
78560
78561   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78562   {
78563     try {
78564       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
78565     } catch (std::out_of_range& e) {
78566       {
78567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (std::exception& e) {
78570       {
78571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (Dali::DaliException e) {
78574       {
78575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78576       };
78577     } catch (...) {
78578       {
78579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78580       };
78581     }
78582   }
78583
78584   jresult = result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
78590   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
78591
78592   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
78593   {
78594     try {
78595       delete arg1;
78596     } catch (std::out_of_range& e) {
78597       {
78598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78599       };
78600     } catch (std::exception& e) {
78601       {
78602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78603       };
78604     } catch (Dali::DaliException e) {
78605       {
78606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78607       };
78608     } catch (...) {
78609       {
78610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78611       };
78612     }
78613   }
78614
78615 }
78616
78617
78618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
78619   float jresult ;
78620   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78621   float arg2 ;
78622   float arg3 ;
78623   float result;
78624
78625   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78626   arg2 = (float)jarg2;
78627   arg3 = (float)jarg3;
78628   {
78629     try {
78630       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
78631     } catch (std::out_of_range& e) {
78632       {
78633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78634       };
78635     } catch (std::exception& e) {
78636       {
78637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78638       };
78639     } catch (Dali::DaliException e) {
78640       {
78641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78642       };
78643     } catch (...) {
78644       {
78645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78646       };
78647     }
78648   }
78649
78650   jresult = result;
78651   return jresult;
78652 }
78653
78654
78655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
78656   float jresult ;
78657   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78658   float arg2 ;
78659   float result;
78660
78661   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78662   arg2 = (float)jarg2;
78663   {
78664     try {
78665       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
78666     } catch (std::out_of_range& e) {
78667       {
78668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78669       };
78670     } catch (std::exception& e) {
78671       {
78672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78673       };
78674     } catch (Dali::DaliException e) {
78675       {
78676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78677       };
78678     } catch (...) {
78679       {
78680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78681       };
78682     }
78683   }
78684
78685   jresult = result;
78686   return jresult;
78687 }
78688
78689
78690 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78691   float jresult ;
78692   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78693   unsigned int arg2 ;
78694   unsigned int *arg3 = 0 ;
78695   bool arg4 ;
78696   float result;
78697
78698   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78699   arg2 = (unsigned int)jarg2;
78700   arg3 = (unsigned int *)jarg3;
78701   arg4 = jarg4 ? true : false;
78702   {
78703     try {
78704       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78705     } catch (std::out_of_range& e) {
78706       {
78707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78708       };
78709     } catch (std::exception& e) {
78710       {
78711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78712       };
78713     } catch (Dali::DaliException e) {
78714       {
78715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78716       };
78717     } catch (...) {
78718       {
78719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78720       };
78721     }
78722   }
78723
78724   jresult = result;
78725   return jresult;
78726 }
78727
78728
78729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78730   unsigned int jresult ;
78731   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78732   float arg2 ;
78733   bool arg3 ;
78734   unsigned int result;
78735
78736   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78737   arg2 = (float)jarg2;
78738   arg3 = jarg3 ? true : false;
78739   {
78740     try {
78741       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
78742     } catch (std::out_of_range& e) {
78743       {
78744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78745       };
78746     } catch (std::exception& e) {
78747       {
78748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78749       };
78750     } catch (Dali::DaliException e) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78753       };
78754     } catch (...) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78757       };
78758     }
78759   }
78760
78761   jresult = result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78767   unsigned int jresult ;
78768   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78769   unsigned int result;
78770
78771   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78772   {
78773     try {
78774       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78775     } catch (std::out_of_range& e) {
78776       {
78777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78778       };
78779     } catch (std::exception& e) {
78780       {
78781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78782       };
78783     } catch (Dali::DaliException e) {
78784       {
78785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78786       };
78787     } catch (...) {
78788       {
78789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78790       };
78791     }
78792   }
78793
78794   jresult = result;
78795   return jresult;
78796 }
78797
78798
78799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78800   int jresult ;
78801   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78802   Dali::Toolkit::Ruler::RulerType result;
78803
78804   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78805   {
78806     try {
78807       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78808     } catch (std::out_of_range& e) {
78809       {
78810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (std::exception& e) {
78813       {
78814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78815       };
78816     } catch (Dali::DaliException e) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78819       };
78820     } catch (...) {
78821       {
78822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78823       };
78824     }
78825   }
78826
78827   jresult = (int)result;
78828   return jresult;
78829 }
78830
78831
78832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78833   unsigned int jresult ;
78834   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78835   bool result;
78836
78837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78838   {
78839     try {
78840       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78841     } catch (std::out_of_range& e) {
78842       {
78843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78844       };
78845     } catch (std::exception& e) {
78846       {
78847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78848       };
78849     } catch (Dali::DaliException e) {
78850       {
78851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78852       };
78853     } catch (...) {
78854       {
78855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78856       };
78857     }
78858   }
78859
78860   jresult = result;
78861   return jresult;
78862 }
78863
78864
78865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78866   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78867
78868   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78869   {
78870     try {
78871       (arg1)->Enable();
78872     } catch (std::out_of_range& e) {
78873       {
78874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78875       };
78876     } catch (std::exception& e) {
78877       {
78878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78879       };
78880     } catch (Dali::DaliException e) {
78881       {
78882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78883       };
78884     } catch (...) {
78885       {
78886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78887       };
78888     }
78889   }
78890
78891 }
78892
78893
78894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78895   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78896
78897   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78898   {
78899     try {
78900       (arg1)->Disable();
78901     } catch (std::out_of_range& e) {
78902       {
78903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78904       };
78905     } catch (std::exception& e) {
78906       {
78907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78908       };
78909     } catch (Dali::DaliException e) {
78910       {
78911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78912       };
78913     } catch (...) {
78914       {
78915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78916       };
78917     }
78918   }
78919
78920 }
78921
78922
78923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78924   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78925   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78926   Dali::Toolkit::RulerDomain *argp2 ;
78927
78928   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78929   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78930   if (!argp2) {
78931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78932     return ;
78933   }
78934   arg2 = *argp2;
78935   {
78936     try {
78937       (arg1)->SetDomain(arg2);
78938     } catch (std::out_of_range& e) {
78939       {
78940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78941       };
78942     } catch (std::exception& e) {
78943       {
78944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78945       };
78946     } catch (Dali::DaliException e) {
78947       {
78948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78949       };
78950     } catch (...) {
78951       {
78952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78953       };
78954     }
78955   }
78956
78957 }
78958
78959
78960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78961   void * jresult ;
78962   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78963   Dali::Toolkit::RulerDomain *result = 0 ;
78964
78965   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78966   {
78967     try {
78968       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78969     } catch (std::out_of_range& e) {
78970       {
78971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78972       };
78973     } catch (std::exception& e) {
78974       {
78975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78976       };
78977     } catch (Dali::DaliException e) {
78978       {
78979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78980       };
78981     } catch (...) {
78982       {
78983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78984       };
78985     }
78986   }
78987
78988   jresult = (void *)result;
78989   return jresult;
78990 }
78991
78992
78993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78994   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78995
78996   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78997   {
78998     try {
78999       (arg1)->DisableDomain();
79000     } catch (std::out_of_range& e) {
79001       {
79002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79003       };
79004     } catch (std::exception& e) {
79005       {
79006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79007       };
79008     } catch (Dali::DaliException e) {
79009       {
79010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79011       };
79012     } catch (...) {
79013       {
79014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79015       };
79016     }
79017   }
79018
79019 }
79020
79021
79022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
79023   float jresult ;
79024   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79025   float arg2 ;
79026   float arg3 ;
79027   float arg4 ;
79028   float result;
79029
79030   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79031   arg2 = (float)jarg2;
79032   arg3 = (float)jarg3;
79033   arg4 = (float)jarg4;
79034   {
79035     try {
79036       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
79037     } catch (std::out_of_range& e) {
79038       {
79039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79040       };
79041     } catch (std::exception& e) {
79042       {
79043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79044       };
79045     } catch (Dali::DaliException e) {
79046       {
79047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79048       };
79049     } catch (...) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79052       };
79053     }
79054   }
79055
79056   jresult = result;
79057   return jresult;
79058 }
79059
79060
79061 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
79062   float jresult ;
79063   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79064   float arg2 ;
79065   float arg3 ;
79066   float result;
79067
79068   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79069   arg2 = (float)jarg2;
79070   arg3 = (float)jarg3;
79071   {
79072     try {
79073       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
79074     } catch (std::out_of_range& e) {
79075       {
79076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79077       };
79078     } catch (std::exception& e) {
79079       {
79080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79081       };
79082     } catch (Dali::DaliException e) {
79083       {
79084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79085       };
79086     } catch (...) {
79087       {
79088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79089       };
79090     }
79091   }
79092
79093   jresult = result;
79094   return jresult;
79095 }
79096
79097
79098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
79099   float jresult ;
79100   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79101   float arg2 ;
79102   float result;
79103
79104   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79105   arg2 = (float)jarg2;
79106   {
79107     try {
79108       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
79109     } catch (std::out_of_range& e) {
79110       {
79111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79112       };
79113     } catch (std::exception& e) {
79114       {
79115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79116       };
79117     } catch (Dali::DaliException e) {
79118       {
79119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79120       };
79121     } catch (...) {
79122       {
79123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79124       };
79125     }
79126   }
79127
79128   jresult = result;
79129   return jresult;
79130 }
79131
79132
79133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
79134   float jresult ;
79135   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79136   float arg2 ;
79137   float arg3 ;
79138   float arg4 ;
79139   Dali::Toolkit::ClampState *arg5 = 0 ;
79140   float result;
79141
79142   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79143   arg2 = (float)jarg2;
79144   arg3 = (float)jarg3;
79145   arg4 = (float)jarg4;
79146   arg5 = (Dali::Toolkit::ClampState *)jarg5;
79147   if (!arg5) {
79148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79149     return 0;
79150   }
79151   {
79152     try {
79153       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
79154     } catch (std::out_of_range& e) {
79155       {
79156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79157       };
79158     } catch (std::exception& e) {
79159       {
79160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79161       };
79162     } catch (Dali::DaliException e) {
79163       {
79164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79165       };
79166     } catch (...) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79169       };
79170     }
79171   }
79172
79173   jresult = result;
79174   return jresult;
79175 }
79176
79177
79178 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
79179   float jresult ;
79180   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79181   float arg2 ;
79182   float arg3 ;
79183   float arg4 ;
79184   float arg5 ;
79185   float result;
79186
79187   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79188   arg2 = (float)jarg2;
79189   arg3 = (float)jarg3;
79190   arg4 = (float)jarg4;
79191   arg5 = (float)jarg5;
79192   {
79193     try {
79194       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
79195     } catch (std::out_of_range& e) {
79196       {
79197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79198       };
79199     } catch (std::exception& e) {
79200       {
79201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79202       };
79203     } catch (Dali::DaliException e) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79206       };
79207     } catch (...) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79210       };
79211     }
79212   }
79213
79214   jresult = result;
79215   return jresult;
79216 }
79217
79218
79219 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
79220   float jresult ;
79221   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79222   float arg2 ;
79223   float arg3 ;
79224   float arg4 ;
79225   float result;
79226
79227   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79228   arg2 = (float)jarg2;
79229   arg3 = (float)jarg3;
79230   arg4 = (float)jarg4;
79231   {
79232     try {
79233       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
79234     } catch (std::out_of_range& e) {
79235       {
79236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79237       };
79238     } catch (std::exception& e) {
79239       {
79240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79241       };
79242     } catch (Dali::DaliException e) {
79243       {
79244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79245       };
79246     } catch (...) {
79247       {
79248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79249       };
79250     }
79251   }
79252
79253   jresult = result;
79254   return jresult;
79255 }
79256
79257
79258 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
79259   float jresult ;
79260   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79261   float arg2 ;
79262   float arg3 ;
79263   float result;
79264
79265   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79266   arg2 = (float)jarg2;
79267   arg3 = (float)jarg3;
79268   {
79269     try {
79270       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (Dali::DaliException e) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289
79290   jresult = result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
79296   float jresult ;
79297   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79298   float arg2 ;
79299   float result;
79300
79301   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79302   arg2 = (float)jarg2;
79303   {
79304     try {
79305       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
79306     } catch (std::out_of_range& e) {
79307       {
79308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79309       };
79310     } catch (std::exception& e) {
79311       {
79312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79313       };
79314     } catch (Dali::DaliException e) {
79315       {
79316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79317       };
79318     } catch (...) {
79319       {
79320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79321       };
79322     }
79323   }
79324
79325   jresult = result;
79326   return jresult;
79327 }
79328
79329
79330 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
79331   float jresult ;
79332   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
79333   float arg2 ;
79334   float arg3 ;
79335   float arg4 ;
79336   float arg5 ;
79337   Dali::Toolkit::ClampState *arg6 = 0 ;
79338   float result;
79339
79340   arg1 = (Dali::Toolkit::Ruler *)jarg1;
79341   arg2 = (float)jarg2;
79342   arg3 = (float)jarg3;
79343   arg4 = (float)jarg4;
79344   arg5 = (float)jarg5;
79345   arg6 = (Dali::Toolkit::ClampState *)jarg6;
79346   if (!arg6) {
79347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
79348     return 0;
79349   }
79350   {
79351     try {
79352       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
79353     } catch (std::out_of_range& e) {
79354       {
79355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79356       };
79357     } catch (std::exception& e) {
79358       {
79359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79360       };
79361     } catch (Dali::DaliException e) {
79362       {
79363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79364       };
79365     } catch (...) {
79366       {
79367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79368       };
79369     }
79370   }
79371
79372   jresult = result;
79373   return jresult;
79374 }
79375
79376
79377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
79378   void * jresult ;
79379   Dali::Toolkit::DefaultRuler *result = 0 ;
79380
79381   {
79382     try {
79383       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
79384     } catch (std::out_of_range& e) {
79385       {
79386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79387       };
79388     } catch (std::exception& e) {
79389       {
79390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79391       };
79392     } catch (Dali::DaliException e) {
79393       {
79394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79395       };
79396     } catch (...) {
79397       {
79398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79399       };
79400     }
79401   }
79402
79403   jresult = (void *)result;
79404   return jresult;
79405 }
79406
79407
79408 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79409   float jresult ;
79410   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79411   float arg2 ;
79412   float arg3 ;
79413   float result;
79414
79415   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79416   arg2 = (float)jarg2;
79417   arg3 = (float)jarg3;
79418   {
79419     try {
79420       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
79421     } catch (std::out_of_range& e) {
79422       {
79423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79424       };
79425     } catch (std::exception& e) {
79426       {
79427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79428       };
79429     } catch (Dali::DaliException e) {
79430       {
79431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79432       };
79433     } catch (...) {
79434       {
79435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79436       };
79437     }
79438   }
79439
79440   jresult = result;
79441   return jresult;
79442 }
79443
79444
79445 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79446   float jresult ;
79447   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79448   unsigned int arg2 ;
79449   unsigned int *arg3 = 0 ;
79450   bool arg4 ;
79451   float result;
79452
79453   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79454   arg2 = (unsigned int)jarg2;
79455   arg3 = (unsigned int *)jarg3;
79456   arg4 = jarg4 ? true : false;
79457   {
79458     try {
79459       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79460     } catch (std::out_of_range& e) {
79461       {
79462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79463       };
79464     } catch (std::exception& e) {
79465       {
79466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79467       };
79468     } catch (Dali::DaliException e) {
79469       {
79470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79471       };
79472     } catch (...) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79475       };
79476     }
79477   }
79478
79479   jresult = result;
79480   return jresult;
79481 }
79482
79483
79484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79485   unsigned int jresult ;
79486   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79487   float arg2 ;
79488   bool arg3 ;
79489   unsigned int result;
79490
79491   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79492   arg2 = (float)jarg2;
79493   arg3 = jarg3 ? true : false;
79494   {
79495     try {
79496       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79497     } catch (std::out_of_range& e) {
79498       {
79499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79500       };
79501     } catch (std::exception& e) {
79502       {
79503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79504       };
79505     } catch (Dali::DaliException e) {
79506       {
79507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79508       };
79509     } catch (...) {
79510       {
79511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79512       };
79513     }
79514   }
79515
79516   jresult = result;
79517   return jresult;
79518 }
79519
79520
79521 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
79522   unsigned int jresult ;
79523   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79524   unsigned int result;
79525
79526   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79527   {
79528     try {
79529       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
79530     } catch (std::out_of_range& e) {
79531       {
79532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79533       };
79534     } catch (std::exception& e) {
79535       {
79536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79537       };
79538     } catch (Dali::DaliException e) {
79539       {
79540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79541       };
79542     } catch (...) {
79543       {
79544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79545       };
79546     }
79547   }
79548
79549   jresult = result;
79550   return jresult;
79551 }
79552
79553
79554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
79555   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
79556
79557   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
79558   {
79559     try {
79560       delete arg1;
79561     } catch (std::out_of_range& e) {
79562       {
79563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79564       };
79565     } catch (std::exception& e) {
79566       {
79567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79568       };
79569     } catch (Dali::DaliException e) {
79570       {
79571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79572       };
79573     } catch (...) {
79574       {
79575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79576       };
79577     }
79578   }
79579
79580 }
79581
79582
79583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
79584   void * jresult ;
79585   float arg1 ;
79586   Dali::Toolkit::FixedRuler *result = 0 ;
79587
79588   arg1 = (float)jarg1;
79589   {
79590     try {
79591       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
79592     } catch (std::out_of_range& e) {
79593       {
79594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79595       };
79596     } catch (std::exception& e) {
79597       {
79598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79599       };
79600     } catch (Dali::DaliException e) {
79601       {
79602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79603       };
79604     } catch (...) {
79605       {
79606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79607       };
79608     }
79609   }
79610
79611   jresult = (void *)result;
79612   return jresult;
79613 }
79614
79615
79616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
79617   void * jresult ;
79618   Dali::Toolkit::FixedRuler *result = 0 ;
79619
79620   {
79621     try {
79622       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
79623     } catch (std::out_of_range& e) {
79624       {
79625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79626       };
79627     } catch (std::exception& e) {
79628       {
79629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79630       };
79631     } catch (Dali::DaliException e) {
79632       {
79633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79634       };
79635     } catch (...) {
79636       {
79637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79638       };
79639     }
79640   }
79641
79642   jresult = (void *)result;
79643   return jresult;
79644 }
79645
79646
79647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
79648   float jresult ;
79649   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79650   float arg2 ;
79651   float arg3 ;
79652   float result;
79653
79654   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79655   arg2 = (float)jarg2;
79656   arg3 = (float)jarg3;
79657   {
79658     try {
79659       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
79660     } catch (std::out_of_range& e) {
79661       {
79662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79663       };
79664     } catch (std::exception& e) {
79665       {
79666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79667       };
79668     } catch (Dali::DaliException e) {
79669       {
79670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79671       };
79672     } catch (...) {
79673       {
79674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79675       };
79676     }
79677   }
79678
79679   jresult = result;
79680   return jresult;
79681 }
79682
79683
79684 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
79685   float jresult ;
79686   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79687   unsigned int arg2 ;
79688   unsigned int *arg3 = 0 ;
79689   bool arg4 ;
79690   float result;
79691
79692   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79693   arg2 = (unsigned int)jarg2;
79694   arg3 = (unsigned int *)jarg3;
79695   arg4 = jarg4 ? true : false;
79696   {
79697     try {
79698       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
79699     } catch (std::out_of_range& e) {
79700       {
79701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79702       };
79703     } catch (std::exception& e) {
79704       {
79705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79706       };
79707     } catch (Dali::DaliException e) {
79708       {
79709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79710       };
79711     } catch (...) {
79712       {
79713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79714       };
79715     }
79716   }
79717
79718   jresult = result;
79719   return jresult;
79720 }
79721
79722
79723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
79724   unsigned int jresult ;
79725   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79726   float arg2 ;
79727   bool arg3 ;
79728   unsigned int result;
79729
79730   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79731   arg2 = (float)jarg2;
79732   arg3 = jarg3 ? true : false;
79733   {
79734     try {
79735       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
79736     } catch (std::out_of_range& e) {
79737       {
79738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79739       };
79740     } catch (std::exception& e) {
79741       {
79742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (Dali::DaliException e) {
79745       {
79746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79747       };
79748     } catch (...) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79751       };
79752     }
79753   }
79754
79755   jresult = result;
79756   return jresult;
79757 }
79758
79759
79760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79761   unsigned int jresult ;
79762   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79763   unsigned int result;
79764
79765   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79766   {
79767     try {
79768       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79769     } catch (std::out_of_range& e) {
79770       {
79771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79772       };
79773     } catch (std::exception& e) {
79774       {
79775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79776       };
79777     } catch (Dali::DaliException e) {
79778       {
79779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79780       };
79781     } catch (...) {
79782       {
79783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79784       };
79785     }
79786   }
79787
79788   jresult = result;
79789   return jresult;
79790 }
79791
79792
79793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79794   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79795
79796   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79797   {
79798     try {
79799       delete arg1;
79800     } catch (std::out_of_range& e) {
79801       {
79802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79803       };
79804     } catch (std::exception& e) {
79805       {
79806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79807       };
79808     } catch (Dali::DaliException e) {
79809       {
79810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79811       };
79812     } catch (...) {
79813       {
79814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79815       };
79816     }
79817   }
79818
79819 }
79820
79821
79822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79823   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79824   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79825
79826   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79827   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79828   if (arg1) (arg1)->scale = *arg2;
79829 }
79830
79831
79832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79833   void * jresult ;
79834   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79835   Dali::Toolkit::ClampState2D *result = 0 ;
79836
79837   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79838   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79839   jresult = (void *)result;
79840   return jresult;
79841 }
79842
79843
79844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79845   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79846   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79847
79848   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79849   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79850   if (arg1) (arg1)->position = *arg2;
79851 }
79852
79853
79854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79855   void * jresult ;
79856   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79857   Dali::Toolkit::ClampState2D *result = 0 ;
79858
79859   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79860   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79861   jresult = (void *)result;
79862   return jresult;
79863 }
79864
79865
79866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79867   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79868   Dali::Toolkit::ClampState arg2 ;
79869
79870   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79871   arg2 = (Dali::Toolkit::ClampState)jarg2;
79872   if (arg1) (arg1)->rotation = arg2;
79873 }
79874
79875
79876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79877   int jresult ;
79878   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79879   Dali::Toolkit::ClampState result;
79880
79881   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79882   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79883   jresult = (int)result;
79884   return jresult;
79885 }
79886
79887
79888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79889   void * jresult ;
79890   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79891
79892   {
79893     try {
79894       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79895     } catch (std::out_of_range& e) {
79896       {
79897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79898       };
79899     } catch (std::exception& e) {
79900       {
79901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79902       };
79903     } catch (Dali::DaliException e) {
79904       {
79905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79906       };
79907     } catch (...) {
79908       {
79909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79910       };
79911     }
79912   }
79913
79914   jresult = (void *)result;
79915   return jresult;
79916 }
79917
79918
79919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79920   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79921
79922   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79923   {
79924     try {
79925       delete arg1;
79926     } catch (std::out_of_range& e) {
79927       {
79928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79929       };
79930     } catch (std::exception& e) {
79931       {
79932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79933       };
79934     } catch (Dali::DaliException e) {
79935       {
79936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79937       };
79938     } catch (...) {
79939       {
79940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79941       };
79942     }
79943   }
79944
79945 }
79946
79947
79948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79949   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79950   Dali::Toolkit::SnapType arg2 ;
79951
79952   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79953   arg2 = (Dali::Toolkit::SnapType)jarg2;
79954   if (arg1) (arg1)->type = arg2;
79955 }
79956
79957
79958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79959   int jresult ;
79960   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79961   Dali::Toolkit::SnapType result;
79962
79963   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79964   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79965   jresult = (int)result;
79966   return jresult;
79967 }
79968
79969
79970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79971   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79972   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79973
79974   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79975   arg2 = (Dali::Vector2 *)jarg2;
79976   if (arg1) (arg1)->position = *arg2;
79977 }
79978
79979
79980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79981   void * jresult ;
79982   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79983   Dali::Vector2 *result = 0 ;
79984
79985   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79986   result = (Dali::Vector2 *)& ((arg1)->position);
79987   jresult = (void *)result;
79988   return jresult;
79989 }
79990
79991
79992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79993   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79994   float arg2 ;
79995
79996   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79997   arg2 = (float)jarg2;
79998   if (arg1) (arg1)->duration = arg2;
79999 }
80000
80001
80002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
80003   float jresult ;
80004   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80005   float result;
80006
80007   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80008   result = (float) ((arg1)->duration);
80009   jresult = result;
80010   return jresult;
80011 }
80012
80013
80014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
80015   void * jresult ;
80016   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
80017
80018   {
80019     try {
80020       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
80021     } catch (std::out_of_range& e) {
80022       {
80023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80024       };
80025     } catch (std::exception& e) {
80026       {
80027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80028       };
80029     } catch (Dali::DaliException e) {
80030       {
80031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80032       };
80033     } catch (...) {
80034       {
80035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80036       };
80037     }
80038   }
80039
80040   jresult = (void *)result;
80041   return jresult;
80042 }
80043
80044
80045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
80046   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
80047
80048   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
80049   {
80050     try {
80051       delete arg1;
80052     } catch (std::out_of_range& e) {
80053       {
80054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80055       };
80056     } catch (std::exception& e) {
80057       {
80058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80059       };
80060     } catch (Dali::DaliException e) {
80061       {
80062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80063       };
80064     } catch (...) {
80065       {
80066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80067       };
80068     }
80069   }
80070
80071 }
80072
80073
80074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
80075   int jresult ;
80076   int result;
80077
80078   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
80079   jresult = (int)result;
80080   return jresult;
80081 }
80082
80083
80084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
80085   int jresult ;
80086   int result;
80087
80088   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
80089   jresult = (int)result;
80090   return jresult;
80091 }
80092
80093
80094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
80095   int jresult ;
80096   int result;
80097
80098   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
80099   jresult = (int)result;
80100   return jresult;
80101 }
80102
80103
80104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
80105   int jresult ;
80106   int result;
80107
80108   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
80109   jresult = (int)result;
80110   return jresult;
80111 }
80112
80113
80114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
80115   int jresult ;
80116   int result;
80117
80118   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
80119   jresult = (int)result;
80120   return jresult;
80121 }
80122
80123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
80124   int jresult ;
80125   int result;
80126
80127   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
80128   jresult = (int)result;
80129   return jresult;
80130 }
80131
80132
80133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
80134   int jresult ;
80135   int result;
80136
80137   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
80138   jresult = (int)result;
80139   return jresult;
80140 }
80141
80142
80143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
80144   int jresult ;
80145   int result;
80146
80147   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
80148   jresult = (int)result;
80149   return jresult;
80150 }
80151
80152
80153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
80154   int jresult ;
80155   int result;
80156
80157   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
80158   jresult = (int)result;
80159   return jresult;
80160 }
80161
80162
80163 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
80164   int jresult ;
80165   int result;
80166
80167   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
80168   jresult = (int)result;
80169   return jresult;
80170 }
80171
80172
80173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
80174   int jresult ;
80175   int result;
80176
80177   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
80178   jresult = (int)result;
80179   return jresult;
80180 }
80181
80182
80183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
80184   int jresult ;
80185   int result;
80186
80187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
80188   jresult = (int)result;
80189   return jresult;
80190 }
80191
80192
80193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
80194   int jresult ;
80195   int result;
80196
80197   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
80198   jresult = (int)result;
80199   return jresult;
80200 }
80201
80202
80203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
80204   int jresult ;
80205   int result;
80206
80207   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
80208   jresult = (int)result;
80209   return jresult;
80210 }
80211
80212
80213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
80214   int jresult ;
80215   int result;
80216
80217   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
80218   jresult = (int)result;
80219   return jresult;
80220 }
80221
80222
80223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
80224   int jresult ;
80225   int result;
80226
80227   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
80228   jresult = (int)result;
80229   return jresult;
80230 }
80231
80232
80233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
80234   int jresult ;
80235   int result;
80236
80237   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
80238   jresult = (int)result;
80239   return jresult;
80240 }
80241
80242
80243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
80244   int jresult ;
80245   int result;
80246
80247   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
80248   jresult = (int)result;
80249   return jresult;
80250 }
80251
80252
80253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
80254   int jresult ;
80255   int result;
80256
80257   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
80258   jresult = (int)result;
80259   return jresult;
80260 }
80261
80262
80263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
80264   int jresult ;
80265   int result;
80266
80267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
80268   jresult = (int)result;
80269   return jresult;
80270 }
80271
80272
80273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
80274   int jresult ;
80275   int result;
80276
80277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
80278   jresult = (int)result;
80279   return jresult;
80280 }
80281
80282
80283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
80284   int jresult ;
80285   int result;
80286
80287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
80288   jresult = (int)result;
80289   return jresult;
80290 }
80291
80292
80293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
80294   int jresult ;
80295   int result;
80296
80297   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
80298   jresult = (int)result;
80299   return jresult;
80300 }
80301
80302
80303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
80304   int jresult ;
80305   int result;
80306
80307   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
80308   jresult = (int)result;
80309   return jresult;
80310 }
80311
80312
80313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
80314   int jresult ;
80315   int result;
80316
80317   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
80318   jresult = (int)result;
80319   return jresult;
80320 }
80321
80322
80323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
80324   int jresult ;
80325   int result;
80326
80327   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
80328   jresult = (int)result;
80329   return jresult;
80330 }
80331
80332
80333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
80334   void * jresult ;
80335   Dali::Toolkit::ScrollView::Property *result = 0 ;
80336
80337   {
80338     try {
80339       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
80340     } catch (std::out_of_range& e) {
80341       {
80342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80343       };
80344     } catch (std::exception& e) {
80345       {
80346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80347       };
80348     } catch (Dali::DaliException e) {
80349       {
80350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80351       };
80352     } catch (...) {
80353       {
80354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80355       };
80356     }
80357   }
80358
80359   jresult = (void *)result;
80360   return jresult;
80361 }
80362
80363
80364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
80365   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
80366
80367   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
80368   {
80369     try {
80370       delete arg1;
80371     } catch (std::out_of_range& e) {
80372       {
80373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80374       };
80375     } catch (std::exception& e) {
80376       {
80377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80378       };
80379     } catch (Dali::DaliException e) {
80380       {
80381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80382       };
80383     } catch (...) {
80384       {
80385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80386       };
80387     }
80388   }
80389
80390 }
80391
80392
80393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
80394   void * jresult ;
80395   Dali::Toolkit::ScrollView *result = 0 ;
80396
80397   {
80398     try {
80399       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
80400     } catch (std::out_of_range& e) {
80401       {
80402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80403       };
80404     } catch (std::exception& e) {
80405       {
80406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80407       };
80408     } catch (Dali::DaliException e) {
80409       {
80410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80411       };
80412     } catch (...) {
80413       {
80414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80415       };
80416     }
80417   }
80418
80419   jresult = (void *)result;
80420   return jresult;
80421 }
80422
80423
80424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
80425   void * jresult ;
80426   Dali::Toolkit::ScrollView *arg1 = 0 ;
80427   Dali::Toolkit::ScrollView *result = 0 ;
80428
80429   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80430   if (!arg1) {
80431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80432     return 0;
80433   }
80434   {
80435     try {
80436       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
80437     } catch (std::out_of_range& e) {
80438       {
80439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80440       };
80441     } catch (std::exception& e) {
80442       {
80443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80444       };
80445     } catch (Dali::DaliException e) {
80446       {
80447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80448       };
80449     } catch (...) {
80450       {
80451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80452       };
80453     }
80454   }
80455
80456   jresult = (void *)result;
80457   return jresult;
80458 }
80459
80460
80461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
80462   void * jresult ;
80463   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80464   Dali::Toolkit::ScrollView *arg2 = 0 ;
80465   Dali::Toolkit::ScrollView *result = 0 ;
80466
80467   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80468   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
80469   if (!arg2) {
80470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
80471     return 0;
80472   }
80473   {
80474     try {
80475       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
80476     } catch (std::out_of_range& e) {
80477       {
80478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80479       };
80480     } catch (std::exception& e) {
80481       {
80482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80483       };
80484     } catch (Dali::DaliException e) {
80485       {
80486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80487       };
80488     } catch (...) {
80489       {
80490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80491       };
80492     }
80493   }
80494
80495   jresult = (void *)result;
80496   return jresult;
80497 }
80498
80499
80500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
80501   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80502
80503   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80504   {
80505     try {
80506       delete arg1;
80507     } catch (std::out_of_range& e) {
80508       {
80509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80510       };
80511     } catch (std::exception& e) {
80512       {
80513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80514       };
80515     } catch (Dali::DaliException e) {
80516       {
80517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80518       };
80519     } catch (...) {
80520       {
80521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80522       };
80523     }
80524   }
80525
80526 }
80527
80528
80529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
80530   void * jresult ;
80531   Dali::Toolkit::ScrollView result;
80532
80533   {
80534     try {
80535       result = Dali::Toolkit::ScrollView::New();
80536     } catch (std::out_of_range& e) {
80537       {
80538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80539       };
80540     } catch (std::exception& e) {
80541       {
80542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80543       };
80544     } catch (Dali::DaliException e) {
80545       {
80546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80547       };
80548     } catch (...) {
80549       {
80550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80551       };
80552     }
80553   }
80554
80555   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80556   return jresult;
80557 }
80558
80559
80560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
80561   void * jresult ;
80562   Dali::BaseHandle arg1 ;
80563   Dali::BaseHandle *argp1 ;
80564   Dali::Toolkit::ScrollView result;
80565
80566   argp1 = (Dali::BaseHandle *)jarg1;
80567   if (!argp1) {
80568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
80569     return 0;
80570   }
80571   arg1 = *argp1;
80572   {
80573     try {
80574       result = Dali::Toolkit::ScrollView::DownCast(arg1);
80575     } catch (std::out_of_range& e) {
80576       {
80577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80578       };
80579     } catch (std::exception& e) {
80580       {
80581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80582       };
80583     } catch (Dali::DaliException e) {
80584       {
80585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80586       };
80587     } catch (...) {
80588       {
80589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80590       };
80591     }
80592   }
80593
80594   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
80595   return jresult;
80596 }
80597
80598
80599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
80600   void * jresult ;
80601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80602   Dali::AlphaFunction result;
80603
80604   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80605   {
80606     try {
80607       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
80608     } catch (std::out_of_range& e) {
80609       {
80610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80611       };
80612     } catch (std::exception& e) {
80613       {
80614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (Dali::DaliException e) {
80617       {
80618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80619       };
80620     } catch (...) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80623       };
80624     }
80625   }
80626
80627   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80628   return jresult;
80629 }
80630
80631
80632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
80633   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80634   Dali::AlphaFunction arg2 ;
80635   Dali::AlphaFunction *argp2 ;
80636
80637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80638   argp2 = (Dali::AlphaFunction *)jarg2;
80639   if (!argp2) {
80640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80641     return ;
80642   }
80643   arg2 = *argp2;
80644   {
80645     try {
80646       (arg1)->SetScrollSnapAlphaFunction(arg2);
80647     } catch (std::out_of_range& e) {
80648       {
80649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80650       };
80651     } catch (std::exception& e) {
80652       {
80653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80654       };
80655     } catch (Dali::DaliException e) {
80656       {
80657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80658       };
80659     } catch (...) {
80660       {
80661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80662       };
80663     }
80664   }
80665
80666 }
80667
80668
80669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
80670   void * jresult ;
80671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80672   Dali::AlphaFunction result;
80673
80674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80675   {
80676     try {
80677       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
80678     } catch (std::out_of_range& e) {
80679       {
80680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80681       };
80682     } catch (std::exception& e) {
80683       {
80684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80685       };
80686     } catch (Dali::DaliException e) {
80687       {
80688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80689       };
80690     } catch (...) {
80691       {
80692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80693       };
80694     }
80695   }
80696
80697   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
80698   return jresult;
80699 }
80700
80701
80702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
80703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80704   Dali::AlphaFunction arg2 ;
80705   Dali::AlphaFunction *argp2 ;
80706
80707   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80708   argp2 = (Dali::AlphaFunction *)jarg2;
80709   if (!argp2) {
80710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80711     return ;
80712   }
80713   arg2 = *argp2;
80714   {
80715     try {
80716       (arg1)->SetScrollFlickAlphaFunction(arg2);
80717     } catch (std::out_of_range& e) {
80718       {
80719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80720       };
80721     } catch (std::exception& e) {
80722       {
80723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80724       };
80725     } catch (Dali::DaliException e) {
80726       {
80727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80728       };
80729     } catch (...) {
80730       {
80731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80732       };
80733     }
80734   }
80735
80736 }
80737
80738
80739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
80740   float jresult ;
80741   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80742   float result;
80743
80744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80745   {
80746     try {
80747       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
80748     } catch (std::out_of_range& e) {
80749       {
80750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (std::exception& e) {
80753       {
80754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80755       };
80756     } catch (Dali::DaliException e) {
80757       {
80758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80759       };
80760     } catch (...) {
80761       {
80762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80763       };
80764     }
80765   }
80766
80767   jresult = result;
80768   return jresult;
80769 }
80770
80771
80772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80774   float arg2 ;
80775
80776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80777   arg2 = (float)jarg2;
80778   {
80779     try {
80780       (arg1)->SetScrollSnapDuration(arg2);
80781     } catch (std::out_of_range& e) {
80782       {
80783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80784       };
80785     } catch (std::exception& e) {
80786       {
80787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80788       };
80789     } catch (Dali::DaliException e) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80792       };
80793     } catch (...) {
80794       {
80795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80796       };
80797     }
80798   }
80799
80800 }
80801
80802
80803 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80804   float jresult ;
80805   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80806   float result;
80807
80808   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80809   {
80810     try {
80811       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80812     } catch (std::out_of_range& e) {
80813       {
80814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80815       };
80816     } catch (std::exception& e) {
80817       {
80818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80819       };
80820     } catch (Dali::DaliException e) {
80821       {
80822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80823       };
80824     } catch (...) {
80825       {
80826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80827       };
80828     }
80829   }
80830
80831   jresult = result;
80832   return jresult;
80833 }
80834
80835
80836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80837   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80838   float arg2 ;
80839
80840   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80841   arg2 = (float)jarg2;
80842   {
80843     try {
80844       (arg1)->SetScrollFlickDuration(arg2);
80845     } catch (std::out_of_range& e) {
80846       {
80847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80848       };
80849     } catch (std::exception& e) {
80850       {
80851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80852       };
80853     } catch (Dali::DaliException e) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80856       };
80857     } catch (...) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80860       };
80861     }
80862   }
80863
80864 }
80865
80866
80867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80868   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80869   Dali::Toolkit::RulerPtr arg2 ;
80870   Dali::Toolkit::RulerPtr *argp2 ;
80871
80872   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80873   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80874   if (!argp2) {
80875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80876     return ;
80877   }
80878   arg2 = *argp2;
80879   {
80880     try {
80881       (arg1)->SetRulerX(arg2);
80882     } catch (std::out_of_range& e) {
80883       {
80884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80885       };
80886     } catch (std::exception& e) {
80887       {
80888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80889       };
80890     } catch (Dali::DaliException e) {
80891       {
80892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80893       };
80894     } catch (...) {
80895       {
80896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80897       };
80898     }
80899   }
80900
80901 }
80902
80903
80904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80906   Dali::Toolkit::RulerPtr arg2 ;
80907   Dali::Toolkit::RulerPtr *argp2 ;
80908
80909   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80910   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80911   if (!argp2) {
80912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80913     return ;
80914   }
80915   arg2 = *argp2;
80916   {
80917     try {
80918       (arg1)->SetRulerY(arg2);
80919     } catch (std::out_of_range& e) {
80920       {
80921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80922       };
80923     } catch (std::exception& e) {
80924       {
80925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80926       };
80927     } catch (Dali::DaliException e) {
80928       {
80929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80930       };
80931     } catch (...) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80934       };
80935     }
80936   }
80937
80938 }
80939
80940
80941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80943   bool arg2 ;
80944
80945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80946   arg2 = jarg2 ? true : false;
80947   {
80948     try {
80949       (arg1)->SetScrollSensitive(arg2);
80950     } catch (std::out_of_range& e) {
80951       {
80952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80953       };
80954     } catch (std::exception& e) {
80955       {
80956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80957       };
80958     } catch (Dali::DaliException e) {
80959       {
80960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80961       };
80962     } catch (...) {
80963       {
80964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80965       };
80966     }
80967   }
80968
80969 }
80970
80971
80972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80974   float arg2 ;
80975   float arg3 ;
80976
80977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80978   arg2 = (float)jarg2;
80979   arg3 = (float)jarg3;
80980   {
80981     try {
80982       (arg1)->SetMaxOvershoot(arg2,arg3);
80983     } catch (std::out_of_range& e) {
80984       {
80985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80986       };
80987     } catch (std::exception& e) {
80988       {
80989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80990       };
80991     } catch (Dali::DaliException e) {
80992       {
80993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80994       };
80995     } catch (...) {
80996       {
80997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80998       };
80999     }
81000   }
81001
81002 }
81003
81004
81005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
81006   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81007   Dali::AlphaFunction arg2 ;
81008   Dali::AlphaFunction *argp2 ;
81009
81010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81011   argp2 = (Dali::AlphaFunction *)jarg2;
81012   if (!argp2) {
81013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81014     return ;
81015   }
81016   arg2 = *argp2;
81017   {
81018     try {
81019       (arg1)->SetSnapOvershootAlphaFunction(arg2);
81020     } catch (std::out_of_range& e) {
81021       {
81022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81023       };
81024     } catch (std::exception& e) {
81025       {
81026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81027       };
81028     } catch (Dali::DaliException e) {
81029       {
81030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81031       };
81032     } catch (...) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81035       };
81036     }
81037   }
81038
81039 }
81040
81041
81042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
81043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81044   float arg2 ;
81045
81046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81047   arg2 = (float)jarg2;
81048   {
81049     try {
81050       (arg1)->SetSnapOvershootDuration(arg2);
81051     } catch (std::out_of_range& e) {
81052       {
81053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81054       };
81055     } catch (std::exception& e) {
81056       {
81057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81058       };
81059     } catch (Dali::DaliException e) {
81060       {
81061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81062       };
81063     } catch (...) {
81064       {
81065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81066       };
81067     }
81068   }
81069
81070 }
81071
81072
81073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
81074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81075   bool arg2 ;
81076
81077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81078   arg2 = jarg2 ? true : false;
81079   {
81080     try {
81081       (arg1)->SetActorAutoSnap(arg2);
81082     } catch (std::out_of_range& e) {
81083       {
81084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81085       };
81086     } catch (std::exception& e) {
81087       {
81088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81089       };
81090     } catch (Dali::DaliException e) {
81091       {
81092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81093       };
81094     } catch (...) {
81095       {
81096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81097       };
81098     }
81099   }
81100
81101 }
81102
81103
81104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
81105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81106   bool arg2 ;
81107
81108   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81109   arg2 = jarg2 ? true : false;
81110   {
81111     try {
81112       (arg1)->SetWrapMode(arg2);
81113     } catch (std::out_of_range& e) {
81114       {
81115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81116       };
81117     } catch (std::exception& e) {
81118       {
81119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81120       };
81121     } catch (Dali::DaliException e) {
81122       {
81123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81124       };
81125     } catch (...) {
81126       {
81127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81128       };
81129     }
81130   }
81131
81132 }
81133
81134
81135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
81136   int jresult ;
81137   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81138   int result;
81139
81140   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81141   {
81142     try {
81143       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
81144     } catch (std::out_of_range& e) {
81145       {
81146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81147       };
81148     } catch (std::exception& e) {
81149       {
81150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81151       };
81152     } catch (Dali::DaliException e) {
81153       {
81154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81155       };
81156     } catch (...) {
81157       {
81158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81159       };
81160     }
81161   }
81162
81163   jresult = result;
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
81169   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81170   int arg2 ;
81171
81172   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81173   arg2 = (int)jarg2;
81174   {
81175     try {
81176       (arg1)->SetScrollUpdateDistance(arg2);
81177     } catch (std::out_of_range& e) {
81178       {
81179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81180       };
81181     } catch (std::exception& e) {
81182       {
81183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81184       };
81185     } catch (Dali::DaliException e) {
81186       {
81187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81188       };
81189     } catch (...) {
81190       {
81191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81192       };
81193     }
81194   }
81195
81196 }
81197
81198
81199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
81200   unsigned int jresult ;
81201   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81202   bool result;
81203
81204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81205   {
81206     try {
81207       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
81208     } catch (std::out_of_range& e) {
81209       {
81210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81211       };
81212     } catch (std::exception& e) {
81213       {
81214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81215       };
81216     } catch (Dali::DaliException e) {
81217       {
81218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81219       };
81220     } catch (...) {
81221       {
81222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81223       };
81224     }
81225   }
81226
81227   jresult = result;
81228   return jresult;
81229 }
81230
81231
81232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
81233   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81234   bool arg2 ;
81235
81236   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81237   arg2 = jarg2 ? true : false;
81238   {
81239     try {
81240       (arg1)->SetAxisAutoLock(arg2);
81241     } catch (std::out_of_range& e) {
81242       {
81243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81244       };
81245     } catch (std::exception& e) {
81246       {
81247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81248       };
81249     } catch (Dali::DaliException e) {
81250       {
81251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81252       };
81253     } catch (...) {
81254       {
81255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81256       };
81257     }
81258   }
81259
81260 }
81261
81262
81263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
81264   float jresult ;
81265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81266   float result;
81267
81268   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81269   {
81270     try {
81271       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
81272     } catch (std::out_of_range& e) {
81273       {
81274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81275       };
81276     } catch (std::exception& e) {
81277       {
81278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81279       };
81280     } catch (Dali::DaliException e) {
81281       {
81282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81283       };
81284     } catch (...) {
81285       {
81286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81287       };
81288     }
81289   }
81290
81291   jresult = result;
81292   return jresult;
81293 }
81294
81295
81296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
81297   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81298   float arg2 ;
81299
81300   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81301   arg2 = (float)jarg2;
81302   {
81303     try {
81304       (arg1)->SetAxisAutoLockGradient(arg2);
81305     } catch (std::out_of_range& e) {
81306       {
81307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81308       };
81309     } catch (std::exception& e) {
81310       {
81311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81312       };
81313     } catch (Dali::DaliException e) {
81314       {
81315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81316       };
81317     } catch (...) {
81318       {
81319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81320       };
81321     }
81322   }
81323
81324 }
81325
81326
81327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
81328   float jresult ;
81329   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81330   float result;
81331
81332   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81333   {
81334     try {
81335       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
81336     } catch (std::out_of_range& e) {
81337       {
81338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81339       };
81340     } catch (std::exception& e) {
81341       {
81342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81343       };
81344     } catch (Dali::DaliException e) {
81345       {
81346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81347       };
81348     } catch (...) {
81349       {
81350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81351       };
81352     }
81353   }
81354
81355   jresult = result;
81356   return jresult;
81357 }
81358
81359
81360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
81361   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81362   float arg2 ;
81363
81364   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81365   arg2 = (float)jarg2;
81366   {
81367     try {
81368       (arg1)->SetFrictionCoefficient(arg2);
81369     } catch (std::out_of_range& e) {
81370       {
81371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81372       };
81373     } catch (std::exception& e) {
81374       {
81375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81376       };
81377     } catch (Dali::DaliException e) {
81378       {
81379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81380       };
81381     } catch (...) {
81382       {
81383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81384       };
81385     }
81386   }
81387
81388 }
81389
81390
81391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
81392   float jresult ;
81393   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81394   float result;
81395
81396   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81397   {
81398     try {
81399       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
81400     } catch (std::out_of_range& e) {
81401       {
81402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81403       };
81404     } catch (std::exception& e) {
81405       {
81406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81407       };
81408     } catch (Dali::DaliException e) {
81409       {
81410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81411       };
81412     } catch (...) {
81413       {
81414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81415       };
81416     }
81417   }
81418
81419   jresult = result;
81420   return jresult;
81421 }
81422
81423
81424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
81425   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81426   float arg2 ;
81427
81428   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81429   arg2 = (float)jarg2;
81430   {
81431     try {
81432       (arg1)->SetFlickSpeedCoefficient(arg2);
81433     } catch (std::out_of_range& e) {
81434       {
81435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81436       };
81437     } catch (std::exception& e) {
81438       {
81439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81440       };
81441     } catch (Dali::DaliException e) {
81442       {
81443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81444       };
81445     } catch (...) {
81446       {
81447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81448       };
81449     }
81450   }
81451
81452 }
81453
81454
81455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
81456   void * jresult ;
81457   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81458   Dali::Vector2 result;
81459
81460   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81461   {
81462     try {
81463       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
81464     } catch (std::out_of_range& e) {
81465       {
81466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81467       };
81468     } catch (std::exception& e) {
81469       {
81470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81471       };
81472     } catch (Dali::DaliException e) {
81473       {
81474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81475       };
81476     } catch (...) {
81477       {
81478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81479       };
81480     }
81481   }
81482
81483   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81484   return jresult;
81485 }
81486
81487
81488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
81489   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81490   Dali::Vector2 *arg2 = 0 ;
81491
81492   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81493   arg2 = (Dali::Vector2 *)jarg2;
81494   if (!arg2) {
81495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81496     return ;
81497   }
81498   {
81499     try {
81500       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
81501     } catch (std::out_of_range& e) {
81502       {
81503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81504       };
81505     } catch (std::exception& e) {
81506       {
81507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (Dali::DaliException e) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81512       };
81513     } catch (...) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81516       };
81517     }
81518   }
81519
81520 }
81521
81522
81523 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
81524   float jresult ;
81525   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81526   float result;
81527
81528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81529   {
81530     try {
81531       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
81532     } catch (std::out_of_range& e) {
81533       {
81534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81535       };
81536     } catch (std::exception& e) {
81537       {
81538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81539       };
81540     } catch (Dali::DaliException e) {
81541       {
81542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81543       };
81544     } catch (...) {
81545       {
81546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81547       };
81548     }
81549   }
81550
81551   jresult = result;
81552   return jresult;
81553 }
81554
81555
81556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
81557   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81558   float arg2 ;
81559
81560   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81561   arg2 = (float)jarg2;
81562   {
81563     try {
81564       (arg1)->SetMinimumSpeedForFlick(arg2);
81565     } catch (std::out_of_range& e) {
81566       {
81567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81568       };
81569     } catch (std::exception& e) {
81570       {
81571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81572       };
81573     } catch (Dali::DaliException e) {
81574       {
81575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81576       };
81577     } catch (...) {
81578       {
81579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81580       };
81581     }
81582   }
81583
81584 }
81585
81586
81587 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
81588   float jresult ;
81589   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81590   float result;
81591
81592   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81593   {
81594     try {
81595       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
81596     } catch (std::out_of_range& e) {
81597       {
81598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81599       };
81600     } catch (std::exception& e) {
81601       {
81602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81603       };
81604     } catch (Dali::DaliException e) {
81605       {
81606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81607       };
81608     } catch (...) {
81609       {
81610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81611       };
81612     }
81613   }
81614
81615   jresult = result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
81621   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81622   float arg2 ;
81623
81624   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81625   arg2 = (float)jarg2;
81626   {
81627     try {
81628       (arg1)->SetMaxFlickSpeed(arg2);
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81636       };
81637     } catch (Dali::DaliException e) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81640       };
81641     } catch (...) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81644       };
81645     }
81646   }
81647
81648 }
81649
81650
81651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
81652   void * jresult ;
81653   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81654   Dali::Vector2 result;
81655
81656   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81657   {
81658     try {
81659       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
81660     } catch (std::out_of_range& e) {
81661       {
81662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81663       };
81664     } catch (std::exception& e) {
81665       {
81666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81667       };
81668     } catch (Dali::DaliException e) {
81669       {
81670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81671       };
81672     } catch (...) {
81673       {
81674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81675       };
81676     }
81677   }
81678
81679   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81680   return jresult;
81681 }
81682
81683
81684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
81685   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81686   Dali::Vector2 arg2 ;
81687   Dali::Vector2 *argp2 ;
81688
81689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81690   argp2 = (Dali::Vector2 *)jarg2;
81691   if (!argp2) {
81692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
81693     return ;
81694   }
81695   arg2 = *argp2;
81696   {
81697     try {
81698       (arg1)->SetWheelScrollDistanceStep(arg2);
81699     } catch (std::out_of_range& e) {
81700       {
81701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81702       };
81703     } catch (std::exception& e) {
81704       {
81705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81706       };
81707     } catch (Dali::DaliException e) {
81708       {
81709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81710       };
81711     } catch (...) {
81712       {
81713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81714       };
81715     }
81716   }
81717
81718 }
81719
81720
81721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
81722   void * jresult ;
81723   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81724   Dali::Vector2 result;
81725
81726   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81727   {
81728     try {
81729       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
81730     } catch (std::out_of_range& e) {
81731       {
81732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81733       };
81734     } catch (std::exception& e) {
81735       {
81736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81737       };
81738     } catch (Dali::DaliException e) {
81739       {
81740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81741       };
81742     } catch (...) {
81743       {
81744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81745       };
81746     }
81747   }
81748
81749   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81750   return jresult;
81751 }
81752
81753
81754 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81755   unsigned int jresult ;
81756   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81757   unsigned int result;
81758
81759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81760   {
81761     try {
81762       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81763     } catch (std::out_of_range& e) {
81764       {
81765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81766       };
81767     } catch (std::exception& e) {
81768       {
81769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81770       };
81771     } catch (Dali::DaliException e) {
81772       {
81773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81774       };
81775     } catch (...) {
81776       {
81777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81778       };
81779     }
81780   }
81781
81782   jresult = result;
81783   return jresult;
81784 }
81785
81786
81787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81789   Dali::Vector2 *arg2 = 0 ;
81790
81791   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81792   arg2 = (Dali::Vector2 *)jarg2;
81793   if (!arg2) {
81794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81795     return ;
81796   }
81797   {
81798     try {
81799       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81800     } catch (std::out_of_range& e) {
81801       {
81802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81803       };
81804     } catch (std::exception& e) {
81805       {
81806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81807       };
81808     } catch (Dali::DaliException e) {
81809       {
81810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81811       };
81812     } catch (...) {
81813       {
81814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81815       };
81816     }
81817   }
81818
81819 }
81820
81821
81822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81823   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81824   Dali::Vector2 *arg2 = 0 ;
81825   float arg3 ;
81826
81827   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81828   arg2 = (Dali::Vector2 *)jarg2;
81829   if (!arg2) {
81830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81831     return ;
81832   }
81833   arg3 = (float)jarg3;
81834   {
81835     try {
81836       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81837     } catch (std::out_of_range& e) {
81838       {
81839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81840       };
81841     } catch (std::exception& e) {
81842       {
81843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81844       };
81845     } catch (Dali::DaliException e) {
81846       {
81847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81848       };
81849     } catch (...) {
81850       {
81851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81852       };
81853     }
81854   }
81855
81856 }
81857
81858
81859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81860   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81861   Dali::Vector2 *arg2 = 0 ;
81862   float arg3 ;
81863   Dali::AlphaFunction arg4 ;
81864   Dali::AlphaFunction *argp4 ;
81865
81866   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81867   arg2 = (Dali::Vector2 *)jarg2;
81868   if (!arg2) {
81869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81870     return ;
81871   }
81872   arg3 = (float)jarg3;
81873   argp4 = (Dali::AlphaFunction *)jarg4;
81874   if (!argp4) {
81875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81876     return ;
81877   }
81878   arg4 = *argp4;
81879   {
81880     try {
81881       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81882     } catch (std::out_of_range& e) {
81883       {
81884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81885       };
81886     } catch (std::exception& e) {
81887       {
81888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81889       };
81890     } catch (Dali::DaliException e) {
81891       {
81892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81893       };
81894     } catch (...) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81897       };
81898     }
81899   }
81900
81901 }
81902
81903
81904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81905   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81906   Dali::Vector2 *arg2 = 0 ;
81907   float arg3 ;
81908   Dali::Toolkit::DirectionBias arg4 ;
81909   Dali::Toolkit::DirectionBias arg5 ;
81910
81911   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81912   arg2 = (Dali::Vector2 *)jarg2;
81913   if (!arg2) {
81914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81915     return ;
81916   }
81917   arg3 = (float)jarg3;
81918   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81919   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81920   {
81921     try {
81922       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81923     } catch (std::out_of_range& e) {
81924       {
81925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81926       };
81927     } catch (std::exception& e) {
81928       {
81929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81930       };
81931     } catch (Dali::DaliException e) {
81932       {
81933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81934       };
81935     } catch (...) {
81936       {
81937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81938       };
81939     }
81940   }
81941
81942 }
81943
81944
81945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81946   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81947   Dali::Vector2 *arg2 = 0 ;
81948   float arg3 ;
81949   Dali::AlphaFunction arg4 ;
81950   Dali::Toolkit::DirectionBias arg5 ;
81951   Dali::Toolkit::DirectionBias arg6 ;
81952   Dali::AlphaFunction *argp4 ;
81953
81954   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81955   arg2 = (Dali::Vector2 *)jarg2;
81956   if (!arg2) {
81957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81958     return ;
81959   }
81960   arg3 = (float)jarg3;
81961   argp4 = (Dali::AlphaFunction *)jarg4;
81962   if (!argp4) {
81963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81964     return ;
81965   }
81966   arg4 = *argp4;
81967   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81968   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81969   {
81970     try {
81971       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81972     } catch (std::out_of_range& e) {
81973       {
81974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81975       };
81976     } catch (std::exception& e) {
81977       {
81978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81979       };
81980     } catch (Dali::DaliException e) {
81981       {
81982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81983       };
81984     } catch (...) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81987       };
81988     }
81989   }
81990
81991 }
81992
81993
81994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81995   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81996   unsigned int arg2 ;
81997
81998   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81999   arg2 = (unsigned int)jarg2;
82000   {
82001     try {
82002       (arg1)->ScrollTo(arg2);
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (Dali::DaliException e) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82014       };
82015     } catch (...) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82018       };
82019     }
82020   }
82021
82022 }
82023
82024
82025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
82026   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82027   unsigned int arg2 ;
82028   float arg3 ;
82029
82030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82031   arg2 = (unsigned int)jarg2;
82032   arg3 = (float)jarg3;
82033   {
82034     try {
82035       (arg1)->ScrollTo(arg2,arg3);
82036     } catch (std::out_of_range& e) {
82037       {
82038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82039       };
82040     } catch (std::exception& e) {
82041       {
82042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82043       };
82044     } catch (Dali::DaliException e) {
82045       {
82046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82047       };
82048     } catch (...) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82051       };
82052     }
82053   }
82054
82055 }
82056
82057
82058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
82059   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82060   unsigned int arg2 ;
82061   float arg3 ;
82062   Dali::Toolkit::DirectionBias arg4 ;
82063
82064   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82065   arg2 = (unsigned int)jarg2;
82066   arg3 = (float)jarg3;
82067   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
82068   {
82069     try {
82070       (arg1)->ScrollTo(arg2,arg3,arg4);
82071     } catch (std::out_of_range& e) {
82072       {
82073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82074       };
82075     } catch (std::exception& e) {
82076       {
82077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82078       };
82079     } catch (Dali::DaliException e) {
82080       {
82081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82082       };
82083     } catch (...) {
82084       {
82085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82086       };
82087     }
82088   }
82089
82090 }
82091
82092
82093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
82094   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82095   Dali::Actor *arg2 = 0 ;
82096
82097   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82098   arg2 = (Dali::Actor *)jarg2;
82099   if (!arg2) {
82100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82101     return ;
82102   }
82103   {
82104     try {
82105       (arg1)->ScrollTo(*arg2);
82106     } catch (std::out_of_range& e) {
82107       {
82108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82109       };
82110     } catch (std::exception& e) {
82111       {
82112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82113       };
82114     } catch (Dali::DaliException e) {
82115       {
82116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82117       };
82118     } catch (...) {
82119       {
82120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82121       };
82122     }
82123   }
82124
82125 }
82126
82127
82128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
82129   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82130   Dali::Actor *arg2 = 0 ;
82131   float arg3 ;
82132
82133   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82134   arg2 = (Dali::Actor *)jarg2;
82135   if (!arg2) {
82136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
82137     return ;
82138   }
82139   arg3 = (float)jarg3;
82140   {
82141     try {
82142       (arg1)->ScrollTo(*arg2,arg3);
82143     } catch (std::out_of_range& e) {
82144       {
82145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82146       };
82147     } catch (std::exception& e) {
82148       {
82149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82150       };
82151     } catch (Dali::DaliException e) {
82152       {
82153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82154       };
82155     } catch (...) {
82156       {
82157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82158       };
82159     }
82160   }
82161
82162 }
82163
82164
82165 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
82166   unsigned int jresult ;
82167   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82168   bool result;
82169
82170   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82171   {
82172     try {
82173       result = (bool)(arg1)->ScrollToSnapPoint();
82174     } catch (std::out_of_range& e) {
82175       {
82176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82177       };
82178     } catch (std::exception& e) {
82179       {
82180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82181       };
82182     } catch (Dali::DaliException e) {
82183       {
82184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82185       };
82186     } catch (...) {
82187       {
82188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82189       };
82190     }
82191   }
82192
82193   jresult = result;
82194   return jresult;
82195 }
82196
82197
82198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
82199   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82200   Dali::Constraint arg2 ;
82201   Dali::Constraint *argp2 ;
82202
82203   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82204   argp2 = (Dali::Constraint *)jarg2;
82205   if (!argp2) {
82206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
82207     return ;
82208   }
82209   arg2 = *argp2;
82210   {
82211     try {
82212       (arg1)->ApplyConstraintToChildren(arg2);
82213     } catch (std::out_of_range& e) {
82214       {
82215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82216       };
82217     } catch (std::exception& e) {
82218       {
82219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82220       };
82221     } catch (Dali::DaliException e) {
82222       {
82223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82224       };
82225     } catch (...) {
82226       {
82227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82228       };
82229     }
82230   }
82231
82232 }
82233
82234
82235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
82236   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82237
82238   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82239   {
82240     try {
82241       (arg1)->RemoveConstraintsFromChildren();
82242     } catch (std::out_of_range& e) {
82243       {
82244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82245       };
82246     } catch (std::exception& e) {
82247       {
82248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82249       };
82250     } catch (Dali::DaliException e) {
82251       {
82252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82253       };
82254     } catch (...) {
82255       {
82256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82257       };
82258     }
82259   }
82260
82261 }
82262
82263
82264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
82265   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82266   Dali::Toolkit::ScrollViewEffect arg2 ;
82267   Dali::Toolkit::ScrollViewEffect *argp2 ;
82268
82269   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82270   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82271   if (!argp2) {
82272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82273     return ;
82274   }
82275   arg2 = *argp2;
82276   {
82277     try {
82278       (arg1)->ApplyEffect(arg2);
82279     } catch (std::out_of_range& e) {
82280       {
82281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82282       };
82283     } catch (std::exception& e) {
82284       {
82285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82286       };
82287     } catch (Dali::DaliException e) {
82288       {
82289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82290       };
82291     } catch (...) {
82292       {
82293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82294       };
82295     }
82296   }
82297
82298 }
82299
82300
82301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
82302   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82303   Dali::Toolkit::ScrollViewEffect arg2 ;
82304   Dali::Toolkit::ScrollViewEffect *argp2 ;
82305
82306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82307   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
82308   if (!argp2) {
82309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
82310     return ;
82311   }
82312   arg2 = *argp2;
82313   {
82314     try {
82315       (arg1)->RemoveEffect(arg2);
82316     } catch (std::out_of_range& e) {
82317       {
82318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82319       };
82320     } catch (std::exception& e) {
82321       {
82322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82323       };
82324     } catch (Dali::DaliException e) {
82325       {
82326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82327       };
82328     } catch (...) {
82329       {
82330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82331       };
82332     }
82333   }
82334
82335 }
82336
82337
82338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
82339   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82340
82341   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82342   {
82343     try {
82344       (arg1)->RemoveAllEffects();
82345     } catch (std::out_of_range& e) {
82346       {
82347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82348       };
82349     } catch (std::exception& e) {
82350       {
82351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82352       };
82353     } catch (Dali::DaliException e) {
82354       {
82355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82356       };
82357     } catch (...) {
82358       {
82359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82360       };
82361     }
82362   }
82363
82364 }
82365
82366
82367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
82368   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82369   Dali::Actor arg2 ;
82370   Dali::Actor *argp2 ;
82371
82372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82373   argp2 = (Dali::Actor *)jarg2;
82374   if (!argp2) {
82375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82376     return ;
82377   }
82378   arg2 = *argp2;
82379   {
82380     try {
82381       (arg1)->BindActor(arg2);
82382     } catch (std::out_of_range& e) {
82383       {
82384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82385       };
82386     } catch (std::exception& e) {
82387       {
82388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82389       };
82390     } catch (Dali::DaliException e) {
82391       {
82392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82393       };
82394     } catch (...) {
82395       {
82396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82397       };
82398     }
82399   }
82400
82401 }
82402
82403
82404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
82405   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82406   Dali::Actor arg2 ;
82407   Dali::Actor *argp2 ;
82408
82409   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82410   argp2 = (Dali::Actor *)jarg2;
82411   if (!argp2) {
82412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82413     return ;
82414   }
82415   arg2 = *argp2;
82416   {
82417     try {
82418       (arg1)->UnbindActor(arg2);
82419     } catch (std::out_of_range& e) {
82420       {
82421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82422       };
82423     } catch (std::exception& e) {
82424       {
82425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82426       };
82427     } catch (Dali::DaliException e) {
82428       {
82429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82430       };
82431     } catch (...) {
82432       {
82433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82434       };
82435     }
82436   }
82437
82438 }
82439
82440
82441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
82442   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82443   Dali::Radian arg2 ;
82444   Dali::Radian arg3 ;
82445   Dali::Radian *argp2 ;
82446   Dali::Radian *argp3 ;
82447
82448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82449   argp2 = (Dali::Radian *)jarg2;
82450   if (!argp2) {
82451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82452     return ;
82453   }
82454   arg2 = *argp2;
82455   argp3 = (Dali::Radian *)jarg3;
82456   if (!argp3) {
82457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82458     return ;
82459   }
82460   arg3 = *argp3;
82461   {
82462     try {
82463       (arg1)->SetScrollingDirection(arg2,arg3);
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82471       };
82472     } catch (Dali::DaliException e) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82475       };
82476     } catch (...) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82479       };
82480     }
82481   }
82482
82483 }
82484
82485
82486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
82487   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82488   Dali::Radian arg2 ;
82489   Dali::Radian *argp2 ;
82490
82491   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82492   argp2 = (Dali::Radian *)jarg2;
82493   if (!argp2) {
82494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82495     return ;
82496   }
82497   arg2 = *argp2;
82498   {
82499     try {
82500       (arg1)->SetScrollingDirection(arg2);
82501     } catch (std::out_of_range& e) {
82502       {
82503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82504       };
82505     } catch (std::exception& e) {
82506       {
82507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82508       };
82509     } catch (Dali::DaliException e) {
82510       {
82511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82512       };
82513     } catch (...) {
82514       {
82515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82516       };
82517     }
82518   }
82519
82520 }
82521
82522
82523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
82524   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82525   Dali::Radian arg2 ;
82526   Dali::Radian *argp2 ;
82527
82528   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82529   argp2 = (Dali::Radian *)jarg2;
82530   if (!argp2) {
82531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
82532     return ;
82533   }
82534   arg2 = *argp2;
82535   {
82536     try {
82537       (arg1)->RemoveScrollingDirection(arg2);
82538     } catch (std::out_of_range& e) {
82539       {
82540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82541       };
82542     } catch (std::exception& e) {
82543       {
82544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82545       };
82546     } catch (Dali::DaliException e) {
82547       {
82548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82549       };
82550     } catch (...) {
82551       {
82552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82553       };
82554     }
82555   }
82556
82557 }
82558
82559
82560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
82561   void * jresult ;
82562   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
82563   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
82564
82565   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
82566   {
82567     try {
82568       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
82569     } catch (std::out_of_range& e) {
82570       {
82571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82572       };
82573     } catch (std::exception& e) {
82574       {
82575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82576       };
82577     } catch (Dali::DaliException e) {
82578       {
82579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82580       };
82581     } catch (...) {
82582       {
82583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82584       };
82585     }
82586   }
82587
82588   jresult = (void *)result;
82589   return jresult;
82590 }
82591
82592
82593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
82594   int jresult ;
82595   int result;
82596
82597   result = (int)Dali::Toolkit::TableView::Property::ROWS;
82598   jresult = (int)result;
82599   return jresult;
82600 }
82601
82602
82603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
82604   int jresult ;
82605   int result;
82606
82607   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
82608   jresult = (int)result;
82609   return jresult;
82610 }
82611
82612
82613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
82614   int jresult ;
82615   int result;
82616
82617   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
82618   jresult = (int)result;
82619   return jresult;
82620 }
82621
82622
82623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
82624   int jresult ;
82625   int result;
82626
82627   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
82628   jresult = (int)result;
82629   return jresult;
82630 }
82631
82632
82633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
82634   int jresult ;
82635   int result;
82636
82637   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
82638   jresult = (int)result;
82639   return jresult;
82640 }
82641
82642
82643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
82644   void * jresult ;
82645   Dali::Toolkit::TableView::Property *result = 0 ;
82646
82647   {
82648     try {
82649       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82657       };
82658     } catch (Dali::DaliException e) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82665       };
82666     }
82667   }
82668
82669   jresult = (void *)result;
82670   return jresult;
82671 }
82672
82673
82674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
82675   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
82676
82677   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
82678   {
82679     try {
82680       delete arg1;
82681     } catch (std::out_of_range& e) {
82682       {
82683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82684       };
82685     } catch (std::exception& e) {
82686       {
82687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82688       };
82689     } catch (Dali::DaliException e) {
82690       {
82691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82692       };
82693     } catch (...) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82696       };
82697     }
82698   }
82699
82700 }
82701
82702
82703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
82704   int jresult ;
82705   int result;
82706
82707   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
82708   jresult = (int)result;
82709   return jresult;
82710 }
82711
82712
82713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
82714   int jresult ;
82715   int result;
82716
82717   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
82718   jresult = (int)result;
82719   return jresult;
82720 }
82721
82722
82723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
82724   int jresult ;
82725   int result;
82726
82727   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
82728   jresult = (int)result;
82729   return jresult;
82730 }
82731
82732
82733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
82734   int jresult ;
82735   int result;
82736
82737   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
82738   jresult = (int)result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
82744   int jresult ;
82745   int result;
82746
82747   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
82748   jresult = (int)result;
82749   return jresult;
82750 }
82751
82752
82753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82754   void * jresult ;
82755   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82756
82757   {
82758     try {
82759       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82760     } catch (std::out_of_range& e) {
82761       {
82762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82763       };
82764     } catch (std::exception& e) {
82765       {
82766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82767       };
82768     } catch (Dali::DaliException e) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82771       };
82772     } catch (...) {
82773       {
82774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82775       };
82776     }
82777   }
82778
82779   jresult = (void *)result;
82780   return jresult;
82781 }
82782
82783
82784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82785   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82786
82787   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82788   {
82789     try {
82790       delete arg1;
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82806       };
82807     }
82808   }
82809
82810 }
82811
82812
82813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82814   void * jresult ;
82815   unsigned int arg1 ;
82816   unsigned int arg2 ;
82817   unsigned int arg3 ;
82818   unsigned int arg4 ;
82819   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82820
82821   arg1 = (unsigned int)jarg1;
82822   arg2 = (unsigned int)jarg2;
82823   arg3 = (unsigned int)jarg3;
82824   arg4 = (unsigned int)jarg4;
82825   {
82826     try {
82827       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82828     } catch (std::out_of_range& e) {
82829       {
82830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82831       };
82832     } catch (std::exception& e) {
82833       {
82834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82835       };
82836     } catch (Dali::DaliException e) {
82837       {
82838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82839       };
82840     } catch (...) {
82841       {
82842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82843       };
82844     }
82845   }
82846
82847   jresult = (void *)result;
82848   return jresult;
82849 }
82850
82851
82852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82853   void * jresult ;
82854   unsigned int arg1 ;
82855   unsigned int arg2 ;
82856   unsigned int arg3 ;
82857   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82858
82859   arg1 = (unsigned int)jarg1;
82860   arg2 = (unsigned int)jarg2;
82861   arg3 = (unsigned int)jarg3;
82862   {
82863     try {
82864       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82865     } catch (std::out_of_range& e) {
82866       {
82867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82868       };
82869     } catch (std::exception& e) {
82870       {
82871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82872       };
82873     } catch (Dali::DaliException e) {
82874       {
82875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82876       };
82877     } catch (...) {
82878       {
82879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82880       };
82881     }
82882   }
82883
82884   jresult = (void *)result;
82885   return jresult;
82886 }
82887
82888
82889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82890   void * jresult ;
82891   unsigned int arg1 ;
82892   unsigned int arg2 ;
82893   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82894
82895   arg1 = (unsigned int)jarg1;
82896   arg2 = (unsigned int)jarg2;
82897   {
82898     try {
82899       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82900     } catch (std::out_of_range& e) {
82901       {
82902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82903       };
82904     } catch (std::exception& e) {
82905       {
82906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82907       };
82908     } catch (Dali::DaliException e) {
82909       {
82910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82911       };
82912     } catch (...) {
82913       {
82914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82915       };
82916     }
82917   }
82918
82919   jresult = (void *)result;
82920   return jresult;
82921 }
82922
82923
82924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82925   void * jresult ;
82926   unsigned int arg1 ;
82927   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82928
82929   arg1 = (unsigned int)jarg1;
82930   {
82931     try {
82932       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82933     } catch (std::out_of_range& e) {
82934       {
82935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82936       };
82937     } catch (std::exception& e) {
82938       {
82939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82940       };
82941     } catch (Dali::DaliException e) {
82942       {
82943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82944       };
82945     } catch (...) {
82946       {
82947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82948       };
82949     }
82950   }
82951
82952   jresult = (void *)result;
82953   return jresult;
82954 }
82955
82956
82957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82958   void * jresult ;
82959   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82960
82961   {
82962     try {
82963       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82964     } catch (std::out_of_range& e) {
82965       {
82966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82967       };
82968     } catch (std::exception& e) {
82969       {
82970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82971       };
82972     } catch (Dali::DaliException e) {
82973       {
82974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82975       };
82976     } catch (...) {
82977       {
82978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82979       };
82980     }
82981   }
82982
82983   jresult = (void *)result;
82984   return jresult;
82985 }
82986
82987
82988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82989   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82990   unsigned int arg2 ;
82991
82992   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82993   arg2 = (unsigned int)jarg2;
82994   if (arg1) (arg1)->rowIndex = arg2;
82995 }
82996
82997
82998 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82999   unsigned int jresult ;
83000   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83001   unsigned int result;
83002
83003   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83004   result = (unsigned int) ((arg1)->rowIndex);
83005   jresult = result;
83006   return jresult;
83007 }
83008
83009
83010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
83011   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83012   unsigned int arg2 ;
83013
83014   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83015   arg2 = (unsigned int)jarg2;
83016   if (arg1) (arg1)->columnIndex = arg2;
83017 }
83018
83019
83020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
83021   unsigned int jresult ;
83022   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83023   unsigned int result;
83024
83025   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83026   result = (unsigned int) ((arg1)->columnIndex);
83027   jresult = result;
83028   return jresult;
83029 }
83030
83031
83032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
83033   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83034   unsigned int arg2 ;
83035
83036   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83037   arg2 = (unsigned int)jarg2;
83038   if (arg1) (arg1)->rowSpan = arg2;
83039 }
83040
83041
83042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
83043   unsigned int jresult ;
83044   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83045   unsigned int result;
83046
83047   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83048   result = (unsigned int) ((arg1)->rowSpan);
83049   jresult = result;
83050   return jresult;
83051 }
83052
83053
83054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
83055   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83056   unsigned int arg2 ;
83057
83058   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83059   arg2 = (unsigned int)jarg2;
83060   if (arg1) (arg1)->columnSpan = arg2;
83061 }
83062
83063
83064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
83065   unsigned int jresult ;
83066   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83067   unsigned int result;
83068
83069   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83070   result = (unsigned int) ((arg1)->columnSpan);
83071   jresult = result;
83072   return jresult;
83073 }
83074
83075
83076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
83077   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
83078
83079   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
83080   {
83081     try {
83082       delete arg1;
83083     } catch (std::out_of_range& e) {
83084       {
83085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83086       };
83087     } catch (std::exception& e) {
83088       {
83089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83090       };
83091     } catch (Dali::DaliException e) {
83092       {
83093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83094       };
83095     } catch (...) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83098       };
83099     }
83100   }
83101
83102 }
83103
83104
83105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
83106   void * jresult ;
83107   Dali::Toolkit::TableView *result = 0 ;
83108
83109   {
83110     try {
83111       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
83112     } catch (std::out_of_range& e) {
83113       {
83114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83115       };
83116     } catch (std::exception& e) {
83117       {
83118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83119       };
83120     } catch (Dali::DaliException e) {
83121       {
83122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83123       };
83124     } catch (...) {
83125       {
83126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83127       };
83128     }
83129   }
83130
83131   jresult = (void *)result;
83132   return jresult;
83133 }
83134
83135
83136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
83137   void * jresult ;
83138   Dali::Toolkit::TableView *arg1 = 0 ;
83139   Dali::Toolkit::TableView *result = 0 ;
83140
83141   arg1 = (Dali::Toolkit::TableView *)jarg1;
83142   if (!arg1) {
83143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83144     return 0;
83145   }
83146   {
83147     try {
83148       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
83149     } catch (std::out_of_range& e) {
83150       {
83151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83152       };
83153     } catch (std::exception& e) {
83154       {
83155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (Dali::DaliException e) {
83158       {
83159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83160       };
83161     } catch (...) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83164       };
83165     }
83166   }
83167
83168   jresult = (void *)result;
83169   return jresult;
83170 }
83171
83172
83173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
83174   void * jresult ;
83175   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83176   Dali::Toolkit::TableView *arg2 = 0 ;
83177   Dali::Toolkit::TableView *result = 0 ;
83178
83179   arg1 = (Dali::Toolkit::TableView *)jarg1;
83180   arg2 = (Dali::Toolkit::TableView *)jarg2;
83181   if (!arg2) {
83182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
83183     return 0;
83184   }
83185   {
83186     try {
83187       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
83188     } catch (std::out_of_range& e) {
83189       {
83190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83191       };
83192     } catch (std::exception& e) {
83193       {
83194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83195       };
83196     } catch (Dali::DaliException e) {
83197       {
83198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83199       };
83200     } catch (...) {
83201       {
83202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83203       };
83204     }
83205   }
83206
83207   jresult = (void *)result;
83208   return jresult;
83209 }
83210
83211
83212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
83213   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83214
83215   arg1 = (Dali::Toolkit::TableView *)jarg1;
83216   {
83217     try {
83218       delete arg1;
83219     } catch (std::out_of_range& e) {
83220       {
83221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83222       };
83223     } catch (std::exception& e) {
83224       {
83225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83226       };
83227     } catch (Dali::DaliException e) {
83228       {
83229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83230       };
83231     } catch (...) {
83232       {
83233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83234       };
83235     }
83236   }
83237
83238 }
83239
83240
83241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
83242   void * jresult ;
83243   unsigned int arg1 ;
83244   unsigned int arg2 ;
83245   Dali::Toolkit::TableView result;
83246
83247   arg1 = (unsigned int)jarg1;
83248   arg2 = (unsigned int)jarg2;
83249   {
83250     try {
83251       result = Dali::Toolkit::TableView::New(arg1,arg2);
83252     } catch (std::out_of_range& e) {
83253       {
83254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83255       };
83256     } catch (std::exception& e) {
83257       {
83258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83259       };
83260     } catch (Dali::DaliException e) {
83261       {
83262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83263       };
83264     } catch (...) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83267       };
83268     }
83269   }
83270
83271   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83272   return jresult;
83273 }
83274
83275
83276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
83277   void * jresult ;
83278   Dali::BaseHandle arg1 ;
83279   Dali::BaseHandle *argp1 ;
83280   Dali::Toolkit::TableView result;
83281
83282   argp1 = (Dali::BaseHandle *)jarg1;
83283   if (!argp1) {
83284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83285     return 0;
83286   }
83287   arg1 = *argp1;
83288   {
83289     try {
83290       result = Dali::Toolkit::TableView::DownCast(arg1);
83291     } catch (std::out_of_range& e) {
83292       {
83293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83294       };
83295     } catch (std::exception& e) {
83296       {
83297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83298       };
83299     } catch (Dali::DaliException e) {
83300       {
83301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83302       };
83303     } catch (...) {
83304       {
83305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83306       };
83307     }
83308   }
83309
83310   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
83311   return jresult;
83312 }
83313
83314
83315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
83316   unsigned int jresult ;
83317   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83318   Dali::Actor arg2 ;
83319   Dali::Toolkit::TableView::CellPosition arg3 ;
83320   Dali::Actor *argp2 ;
83321   Dali::Toolkit::TableView::CellPosition *argp3 ;
83322   bool result;
83323
83324   arg1 = (Dali::Toolkit::TableView *)jarg1;
83325   argp2 = (Dali::Actor *)jarg2;
83326   if (!argp2) {
83327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83328     return 0;
83329   }
83330   arg2 = *argp2;
83331   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83332   if (!argp3) {
83333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83334     return 0;
83335   }
83336   arg3 = *argp3;
83337   {
83338     try {
83339       result = (bool)(arg1)->AddChild(arg2,arg3);
83340     } catch (std::out_of_range& e) {
83341       {
83342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83343       };
83344     } catch (std::exception& e) {
83345       {
83346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83347       };
83348     } catch (Dali::DaliException e) {
83349       {
83350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83351       };
83352     } catch (...) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83355       };
83356     }
83357   }
83358
83359   jresult = result;
83360   return jresult;
83361 }
83362
83363
83364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
83365   void * jresult ;
83366   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83367   Dali::Toolkit::TableView::CellPosition arg2 ;
83368   Dali::Toolkit::TableView::CellPosition *argp2 ;
83369   Dali::Actor result;
83370
83371   arg1 = (Dali::Toolkit::TableView *)jarg1;
83372   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83373   if (!argp2) {
83374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83375     return 0;
83376   }
83377   arg2 = *argp2;
83378   {
83379     try {
83380       result = (arg1)->GetChildAt(arg2);
83381     } catch (std::out_of_range& e) {
83382       {
83383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83384       };
83385     } catch (std::exception& e) {
83386       {
83387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83388       };
83389     } catch (Dali::DaliException e) {
83390       {
83391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83392       };
83393     } catch (...) {
83394       {
83395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83396       };
83397     }
83398   }
83399
83400   jresult = new Dali::Actor((const Dali::Actor &)result);
83401   return jresult;
83402 }
83403
83404
83405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
83406   void * jresult ;
83407   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83408   Dali::Toolkit::TableView::CellPosition arg2 ;
83409   Dali::Toolkit::TableView::CellPosition *argp2 ;
83410   Dali::Actor result;
83411
83412   arg1 = (Dali::Toolkit::TableView *)jarg1;
83413   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83414   if (!argp2) {
83415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83416     return 0;
83417   }
83418   arg2 = *argp2;
83419   {
83420     try {
83421       result = (arg1)->RemoveChildAt(arg2);
83422     } catch (std::out_of_range& e) {
83423       {
83424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83425       };
83426     } catch (std::exception& e) {
83427       {
83428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83429       };
83430     } catch (Dali::DaliException e) {
83431       {
83432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83433       };
83434     } catch (...) {
83435       {
83436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83437       };
83438     }
83439   }
83440
83441   jresult = new Dali::Actor((const Dali::Actor &)result);
83442   return jresult;
83443 }
83444
83445
83446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
83447   unsigned int jresult ;
83448   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83449   Dali::Actor arg2 ;
83450   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
83451   Dali::Actor *argp2 ;
83452   bool result;
83453
83454   arg1 = (Dali::Toolkit::TableView *)jarg1;
83455   argp2 = (Dali::Actor *)jarg2;
83456   if (!argp2) {
83457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83458     return 0;
83459   }
83460   arg2 = *argp2;
83461   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
83462   if (!arg3) {
83463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
83464     return 0;
83465   }
83466   {
83467     try {
83468       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
83469     } catch (std::out_of_range& e) {
83470       {
83471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83472       };
83473     } catch (std::exception& e) {
83474       {
83475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83476       };
83477     } catch (Dali::DaliException e) {
83478       {
83479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83480       };
83481     } catch (...) {
83482       {
83483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83484       };
83485     }
83486   }
83487
83488   jresult = result;
83489   return jresult;
83490 }
83491
83492
83493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
83494   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83495   unsigned int arg2 ;
83496
83497   arg1 = (Dali::Toolkit::TableView *)jarg1;
83498   arg2 = (unsigned int)jarg2;
83499   {
83500     try {
83501       (arg1)->InsertRow(arg2);
83502     } catch (std::out_of_range& e) {
83503       {
83504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83505       };
83506     } catch (std::exception& e) {
83507       {
83508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83509       };
83510     } catch (Dali::DaliException e) {
83511       {
83512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83513       };
83514     } catch (...) {
83515       {
83516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83517       };
83518     }
83519   }
83520
83521 }
83522
83523
83524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
83525   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83526   unsigned int arg2 ;
83527
83528   arg1 = (Dali::Toolkit::TableView *)jarg1;
83529   arg2 = (unsigned int)jarg2;
83530   {
83531     try {
83532       (arg1)->DeleteRow(arg2);
83533     } catch (std::out_of_range& e) {
83534       {
83535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83536       };
83537     } catch (std::exception& e) {
83538       {
83539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83540       };
83541     } catch (Dali::DaliException e) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83544       };
83545     } catch (...) {
83546       {
83547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83548       };
83549     }
83550   }
83551
83552 }
83553
83554
83555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83556   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83557   unsigned int arg2 ;
83558   std::vector< Dali::Actor > *arg3 = 0 ;
83559
83560   arg1 = (Dali::Toolkit::TableView *)jarg1;
83561   arg2 = (unsigned int)jarg2;
83562   arg3 = (std::vector< Dali::Actor > *)jarg3;
83563   if (!arg3) {
83564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83565     return ;
83566   }
83567   {
83568     try {
83569       (arg1)->DeleteRow(arg2,*arg3);
83570     } catch (std::out_of_range& e) {
83571       {
83572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83573       };
83574     } catch (std::exception& e) {
83575       {
83576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83577       };
83578     } catch (Dali::DaliException e) {
83579       {
83580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83581       };
83582     } catch (...) {
83583       {
83584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83585       };
83586     }
83587   }
83588
83589 }
83590
83591
83592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
83593   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83594   unsigned int arg2 ;
83595
83596   arg1 = (Dali::Toolkit::TableView *)jarg1;
83597   arg2 = (unsigned int)jarg2;
83598   {
83599     try {
83600       (arg1)->InsertColumn(arg2);
83601     } catch (std::out_of_range& e) {
83602       {
83603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83604       };
83605     } catch (std::exception& e) {
83606       {
83607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83608       };
83609     } catch (Dali::DaliException e) {
83610       {
83611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83612       };
83613     } catch (...) {
83614       {
83615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83616       };
83617     }
83618   }
83619
83620 }
83621
83622
83623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
83624   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83625   unsigned int arg2 ;
83626
83627   arg1 = (Dali::Toolkit::TableView *)jarg1;
83628   arg2 = (unsigned int)jarg2;
83629   {
83630     try {
83631       (arg1)->DeleteColumn(arg2);
83632     } catch (std::out_of_range& e) {
83633       {
83634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83635       };
83636     } catch (std::exception& e) {
83637       {
83638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83639       };
83640     } catch (Dali::DaliException e) {
83641       {
83642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83643       };
83644     } catch (...) {
83645       {
83646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83647       };
83648     }
83649   }
83650
83651 }
83652
83653
83654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
83655   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83656   unsigned int arg2 ;
83657   std::vector< Dali::Actor > *arg3 = 0 ;
83658
83659   arg1 = (Dali::Toolkit::TableView *)jarg1;
83660   arg2 = (unsigned int)jarg2;
83661   arg3 = (std::vector< Dali::Actor > *)jarg3;
83662   if (!arg3) {
83663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83664     return ;
83665   }
83666   {
83667     try {
83668       (arg1)->DeleteColumn(arg2,*arg3);
83669     } catch (std::out_of_range& e) {
83670       {
83671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83672       };
83673     } catch (std::exception& e) {
83674       {
83675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83676       };
83677     } catch (Dali::DaliException e) {
83678       {
83679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83680       };
83681     } catch (...) {
83682       {
83683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83684       };
83685     }
83686   }
83687
83688 }
83689
83690
83691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
83692   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83693   unsigned int arg2 ;
83694   unsigned int arg3 ;
83695
83696   arg1 = (Dali::Toolkit::TableView *)jarg1;
83697   arg2 = (unsigned int)jarg2;
83698   arg3 = (unsigned int)jarg3;
83699   {
83700     try {
83701       (arg1)->Resize(arg2,arg3);
83702     } catch (std::out_of_range& e) {
83703       {
83704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83705       };
83706     } catch (std::exception& e) {
83707       {
83708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83709       };
83710     } catch (Dali::DaliException e) {
83711       {
83712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83713       };
83714     } catch (...) {
83715       {
83716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83717       };
83718     }
83719   }
83720
83721 }
83722
83723
83724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
83725   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83726   unsigned int arg2 ;
83727   unsigned int arg3 ;
83728   std::vector< Dali::Actor > *arg4 = 0 ;
83729
83730   arg1 = (Dali::Toolkit::TableView *)jarg1;
83731   arg2 = (unsigned int)jarg2;
83732   arg3 = (unsigned int)jarg3;
83733   arg4 = (std::vector< Dali::Actor > *)jarg4;
83734   if (!arg4) {
83735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
83736     return ;
83737   }
83738   {
83739     try {
83740       (arg1)->Resize(arg2,arg3,*arg4);
83741     } catch (std::out_of_range& e) {
83742       {
83743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83744       };
83745     } catch (std::exception& e) {
83746       {
83747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83748       };
83749     } catch (Dali::DaliException e) {
83750       {
83751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83752       };
83753     } catch (...) {
83754       {
83755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83756       };
83757     }
83758   }
83759
83760 }
83761
83762
83763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83764   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83765   Dali::Size arg2 ;
83766   Dali::Size *argp2 ;
83767
83768   arg1 = (Dali::Toolkit::TableView *)jarg1;
83769   argp2 = (Dali::Size *)jarg2;
83770   if (!argp2) {
83771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83772     return ;
83773   }
83774   arg2 = *argp2;
83775   {
83776     try {
83777       (arg1)->SetCellPadding(arg2);
83778     } catch (std::out_of_range& e) {
83779       {
83780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83781       };
83782     } catch (std::exception& e) {
83783       {
83784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83785       };
83786     } catch (Dali::DaliException e) {
83787       {
83788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83789       };
83790     } catch (...) {
83791       {
83792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83793       };
83794     }
83795   }
83796
83797 }
83798
83799
83800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83801   void * jresult ;
83802   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83803   Dali::Size result;
83804
83805   arg1 = (Dali::Toolkit::TableView *)jarg1;
83806   {
83807     try {
83808       result = (arg1)->GetCellPadding();
83809     } catch (std::out_of_range& e) {
83810       {
83811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83812       };
83813     } catch (std::exception& e) {
83814       {
83815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83816       };
83817     } catch (Dali::DaliException e) {
83818       {
83819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83820       };
83821     } catch (...) {
83822       {
83823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83824       };
83825     }
83826   }
83827
83828   jresult = new Dali::Size((const Dali::Size &)result);
83829   return jresult;
83830 }
83831
83832
83833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83834   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83835   unsigned int arg2 ;
83836
83837   arg1 = (Dali::Toolkit::TableView *)jarg1;
83838   arg2 = (unsigned int)jarg2;
83839   {
83840     try {
83841       (arg1)->SetFitHeight(arg2);
83842     } catch (std::out_of_range& e) {
83843       {
83844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83845       };
83846     } catch (std::exception& e) {
83847       {
83848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83849       };
83850     } catch (Dali::DaliException e) {
83851       {
83852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83853       };
83854     } catch (...) {
83855       {
83856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83857       };
83858     }
83859   }
83860
83861 }
83862
83863
83864 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83865   unsigned int jresult ;
83866   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83867   unsigned int arg2 ;
83868   bool result;
83869
83870   arg1 = (Dali::Toolkit::TableView *)jarg1;
83871   arg2 = (unsigned int)jarg2;
83872   {
83873     try {
83874       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83875     } catch (std::out_of_range& e) {
83876       {
83877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83878       };
83879     } catch (std::exception& e) {
83880       {
83881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83882       };
83883     } catch (Dali::DaliException e) {
83884       {
83885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83886       };
83887     } catch (...) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83890       };
83891     }
83892   }
83893
83894   jresult = result;
83895   return jresult;
83896 }
83897
83898
83899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83900   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83901   unsigned int arg2 ;
83902
83903   arg1 = (Dali::Toolkit::TableView *)jarg1;
83904   arg2 = (unsigned int)jarg2;
83905   {
83906     try {
83907       (arg1)->SetFitWidth(arg2);
83908     } catch (std::out_of_range& e) {
83909       {
83910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83911       };
83912     } catch (std::exception& e) {
83913       {
83914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83915       };
83916     } catch (Dali::DaliException e) {
83917       {
83918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83919       };
83920     } catch (...) {
83921       {
83922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83923       };
83924     }
83925   }
83926
83927 }
83928
83929
83930 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83931   unsigned int jresult ;
83932   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83933   unsigned int arg2 ;
83934   bool result;
83935
83936   arg1 = (Dali::Toolkit::TableView *)jarg1;
83937   arg2 = (unsigned int)jarg2;
83938   {
83939     try {
83940       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83948       };
83949     } catch (Dali::DaliException e) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83952       };
83953     } catch (...) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83956       };
83957     }
83958   }
83959
83960   jresult = result;
83961   return jresult;
83962 }
83963
83964
83965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83966   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83967   unsigned int arg2 ;
83968   float arg3 ;
83969
83970   arg1 = (Dali::Toolkit::TableView *)jarg1;
83971   arg2 = (unsigned int)jarg2;
83972   arg3 = (float)jarg3;
83973   {
83974     try {
83975       (arg1)->SetFixedHeight(arg2,arg3);
83976     } catch (std::out_of_range& e) {
83977       {
83978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83979       };
83980     } catch (std::exception& e) {
83981       {
83982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83983       };
83984     } catch (Dali::DaliException e) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83987       };
83988     } catch (...) {
83989       {
83990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83991       };
83992     }
83993   }
83994
83995 }
83996
83997
83998 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83999   float jresult ;
84000   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84001   unsigned int arg2 ;
84002   float result;
84003
84004   arg1 = (Dali::Toolkit::TableView *)jarg1;
84005   arg2 = (unsigned int)jarg2;
84006   {
84007     try {
84008       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
84009     } catch (std::out_of_range& e) {
84010       {
84011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84012       };
84013     } catch (std::exception& e) {
84014       {
84015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84016       };
84017     } catch (Dali::DaliException e) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84020       };
84021     } catch (...) {
84022       {
84023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84024       };
84025     }
84026   }
84027
84028   jresult = result;
84029   return jresult;
84030 }
84031
84032
84033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
84034   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84035   unsigned int arg2 ;
84036   float arg3 ;
84037
84038   arg1 = (Dali::Toolkit::TableView *)jarg1;
84039   arg2 = (unsigned int)jarg2;
84040   arg3 = (float)jarg3;
84041   {
84042     try {
84043       (arg1)->SetRelativeHeight(arg2,arg3);
84044     } catch (std::out_of_range& e) {
84045       {
84046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84047       };
84048     } catch (std::exception& e) {
84049       {
84050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84051       };
84052     } catch (Dali::DaliException e) {
84053       {
84054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84055       };
84056     } catch (...) {
84057       {
84058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84059       };
84060     }
84061   }
84062
84063 }
84064
84065
84066 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
84067   float jresult ;
84068   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84069   unsigned int arg2 ;
84070   float result;
84071
84072   arg1 = (Dali::Toolkit::TableView *)jarg1;
84073   arg2 = (unsigned int)jarg2;
84074   {
84075     try {
84076       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
84077     } catch (std::out_of_range& e) {
84078       {
84079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84080       };
84081     } catch (std::exception& e) {
84082       {
84083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84084       };
84085     } catch (Dali::DaliException e) {
84086       {
84087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84088       };
84089     } catch (...) {
84090       {
84091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84092       };
84093     }
84094   }
84095
84096   jresult = result;
84097   return jresult;
84098 }
84099
84100
84101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84102   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84103   unsigned int arg2 ;
84104   float arg3 ;
84105
84106   arg1 = (Dali::Toolkit::TableView *)jarg1;
84107   arg2 = (unsigned int)jarg2;
84108   arg3 = (float)jarg3;
84109   {
84110     try {
84111       (arg1)->SetFixedWidth(arg2,arg3);
84112     } catch (std::out_of_range& e) {
84113       {
84114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84115       };
84116     } catch (std::exception& e) {
84117       {
84118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84119       };
84120     } catch (Dali::DaliException e) {
84121       {
84122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84123       };
84124     } catch (...) {
84125       {
84126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84127       };
84128     }
84129   }
84130
84131 }
84132
84133
84134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
84135   float jresult ;
84136   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84137   unsigned int arg2 ;
84138   float result;
84139
84140   arg1 = (Dali::Toolkit::TableView *)jarg1;
84141   arg2 = (unsigned int)jarg2;
84142   {
84143     try {
84144       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
84145     } catch (std::out_of_range& e) {
84146       {
84147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84148       };
84149     } catch (std::exception& e) {
84150       {
84151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84152       };
84153     } catch (Dali::DaliException e) {
84154       {
84155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84156       };
84157     } catch (...) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84160       };
84161     }
84162   }
84163
84164   jresult = result;
84165   return jresult;
84166 }
84167
84168
84169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
84170   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84171   unsigned int arg2 ;
84172   float arg3 ;
84173
84174   arg1 = (Dali::Toolkit::TableView *)jarg1;
84175   arg2 = (unsigned int)jarg2;
84176   arg3 = (float)jarg3;
84177   {
84178     try {
84179       (arg1)->SetRelativeWidth(arg2,arg3);
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84195       };
84196     }
84197   }
84198
84199 }
84200
84201
84202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
84203   float jresult ;
84204   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84205   unsigned int arg2 ;
84206   float result;
84207
84208   arg1 = (Dali::Toolkit::TableView *)jarg1;
84209   arg2 = (unsigned int)jarg2;
84210   {
84211     try {
84212       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
84213     } catch (std::out_of_range& e) {
84214       {
84215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84216       };
84217     } catch (std::exception& e) {
84218       {
84219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84220       };
84221     } catch (Dali::DaliException e) {
84222       {
84223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84224       };
84225     } catch (...) {
84226       {
84227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84228       };
84229     }
84230   }
84231
84232   jresult = result;
84233   return jresult;
84234 }
84235
84236
84237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
84238   unsigned int jresult ;
84239   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84240   unsigned int result;
84241
84242   arg1 = (Dali::Toolkit::TableView *)jarg1;
84243   {
84244     try {
84245       result = (unsigned int)(arg1)->GetRows();
84246     } catch (std::out_of_range& e) {
84247       {
84248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84249       };
84250     } catch (std::exception& e) {
84251       {
84252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84253       };
84254     } catch (Dali::DaliException e) {
84255       {
84256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84257       };
84258     } catch (...) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84261       };
84262     }
84263   }
84264
84265   jresult = result;
84266   return jresult;
84267 }
84268
84269
84270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
84271   unsigned int jresult ;
84272   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84273   unsigned int result;
84274
84275   arg1 = (Dali::Toolkit::TableView *)jarg1;
84276   {
84277     try {
84278       result = (unsigned int)(arg1)->GetColumns();
84279     } catch (std::out_of_range& e) {
84280       {
84281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (std::exception& e) {
84284       {
84285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (Dali::DaliException e) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84290       };
84291     } catch (...) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84294       };
84295     }
84296   }
84297
84298   jresult = result;
84299   return jresult;
84300 }
84301
84302
84303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
84304   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
84305   Dali::Toolkit::TableView::CellPosition arg2 ;
84306   Dali::HorizontalAlignment::Type arg3 ;
84307   Dali::VerticalAlignment::Type arg4 ;
84308   Dali::Toolkit::TableView::CellPosition *argp2 ;
84309
84310   arg1 = (Dali::Toolkit::TableView *)jarg1;
84311   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
84312   if (!argp2) {
84313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
84314     return ;
84315   }
84316   arg2 = *argp2;
84317   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
84318   arg4 = (Dali::VerticalAlignment::Type)jarg4;
84319   {
84320     try {
84321       (arg1)->SetCellAlignment(arg2,arg3,arg4);
84322     } catch (std::out_of_range& e) {
84323       {
84324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84325       };
84326     } catch (std::exception& e) {
84327       {
84328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84329       };
84330     } catch (Dali::DaliException e) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84333       };
84334     } catch (...) {
84335       {
84336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84337       };
84338     }
84339   }
84340
84341 }
84342
84343
84344 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
84345   unsigned int jresult ;
84346   unsigned int result;
84347
84348   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
84349   jresult = result;
84350   return jresult;
84351 }
84352
84353
84354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
84355   int jresult ;
84356   int result;
84357
84358   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
84359   jresult = (int)result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
84365   int jresult ;
84366   int result;
84367
84368   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
84369   jresult = (int)result;
84370   return jresult;
84371 }
84372
84373
84374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
84375   int jresult ;
84376   int result;
84377
84378   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
84379   jresult = (int)result;
84380   return jresult;
84381 }
84382
84383
84384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
84385   int jresult ;
84386   int result;
84387
84388   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
84389   jresult = (int)result;
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
84395   int jresult ;
84396   int result;
84397
84398   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
84399   jresult = (int)result;
84400   return jresult;
84401 }
84402
84403
84404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
84405   int jresult ;
84406   int result;
84407
84408   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
84409   jresult = (int)result;
84410   return jresult;
84411 }
84412
84413
84414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
84415   int jresult ;
84416   int result;
84417
84418   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
84419   jresult = (int)result;
84420   return jresult;
84421 }
84422
84423
84424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
84425   int jresult ;
84426   int result;
84427
84428   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
84429   jresult = (int)result;
84430   return jresult;
84431 }
84432
84433
84434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
84435   int jresult ;
84436   int result;
84437
84438   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
84439   jresult = (int)result;
84440   return jresult;
84441 }
84442
84443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_OFFSET_get() {
84444   int jresult ;
84445   int result;
84446
84447   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_OFFSET;
84448   jresult = (int)result;
84449   return jresult;
84450 }
84451
84452
84453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_COLOR_get() {
84454   int jresult ;
84455   int result;
84456
84457   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW_COLOR;
84458   jresult = (int)result;
84459   return jresult;
84460 }
84461
84462
84463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_ENABLED_get() {
84464   int jresult ;
84465   int result;
84466
84467   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_ENABLED;
84468   jresult = (int)result;
84469   return jresult;
84470 }
84471
84472
84473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_COLOR_get() {
84474   int jresult ;
84475   int result;
84476
84477   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_COLOR;
84478   jresult = (int)result;
84479   return jresult;
84480 }
84481
84482
84483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_HEIGHT_get() {
84484   int jresult ;
84485   int result;
84486
84487   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE_HEIGHT;
84488   jresult = (int)result;
84489   return jresult;
84490 }
84491
84492
84493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
84494   int jresult ;
84495   int result;
84496
84497   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
84498   jresult = (int)result;
84499   return jresult;
84500 }
84501
84502
84503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
84504   int jresult ;
84505   int result;
84506
84507   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
84508   jresult = (int)result;
84509   return jresult;
84510 }
84511
84512
84513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
84514   int jresult ;
84515   int result;
84516
84517   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
84518   jresult = (int)result;
84519   return jresult;
84520 }
84521
84522
84523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
84524   int jresult ;
84525   int result;
84526
84527   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
84528   jresult = (int)result;
84529   return jresult;
84530 }
84531
84532
84533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
84534   int jresult ;
84535   int result;
84536
84537   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
84538   jresult = (int)result;
84539   return jresult;
84540 }
84541
84542
84543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
84544   int jresult ;
84545   int result;
84546
84547   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
84548   jresult = (int)result;
84549   return jresult;
84550 }
84551
84552
84553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
84554   int jresult ;
84555   int result;
84556
84557   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
84558   jresult = (int)result;
84559   return jresult;
84560 }
84561
84562
84563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
84564   int jresult ;
84565   int result;
84566
84567   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
84568   jresult = (int)result;
84569   return jresult;
84570 }
84571
84572
84573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
84574   int jresult ;
84575   int result;
84576
84577   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
84578   jresult = (int)result;
84579   return jresult;
84580 }
84581
84582
84583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
84584   int jresult ;
84585   int result;
84586
84587   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
84588   jresult = (int)result;
84589   return jresult;
84590 }
84591
84592
84593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
84594   void * jresult ;
84595   Dali::Toolkit::TextLabel::Property *result = 0 ;
84596
84597   {
84598     try {
84599       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
84600     } catch (std::out_of_range& e) {
84601       {
84602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84603       };
84604     } catch (std::exception& e) {
84605       {
84606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84607       };
84608     } catch (Dali::DaliException e) {
84609       {
84610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84611       };
84612     } catch (...) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84615       };
84616     }
84617   }
84618
84619   jresult = (void *)result;
84620   return jresult;
84621 }
84622
84623
84624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
84625   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
84626
84627   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
84628   {
84629     try {
84630       delete arg1;
84631     } catch (std::out_of_range& e) {
84632       {
84633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84634       };
84635     } catch (std::exception& e) {
84636       {
84637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84638       };
84639     } catch (Dali::DaliException e) {
84640       {
84641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84642       };
84643     } catch (...) {
84644       {
84645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84646       };
84647     }
84648   }
84649
84650 }
84651
84652
84653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
84654   void * jresult ;
84655   Dali::Toolkit::TextLabel result;
84656
84657   {
84658     try {
84659       result = Dali::Toolkit::TextLabel::New();
84660     } catch (std::out_of_range& e) {
84661       {
84662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84663       };
84664     } catch (std::exception& e) {
84665       {
84666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84667       };
84668     } catch (Dali::DaliException e) {
84669       {
84670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84671       };
84672     } catch (...) {
84673       {
84674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84675       };
84676     }
84677   }
84678
84679   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84680   return jresult;
84681 }
84682
84683
84684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
84685   void * jresult ;
84686   std::string *arg1 = 0 ;
84687   Dali::Toolkit::TextLabel result;
84688
84689   if (!jarg1) {
84690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84691     return 0;
84692   }
84693   std::string arg1_str(jarg1);
84694   arg1 = &arg1_str;
84695   {
84696     try {
84697       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
84698     } catch (std::out_of_range& e) {
84699       {
84700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84701       };
84702     } catch (std::exception& e) {
84703       {
84704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84705       };
84706     } catch (Dali::DaliException e) {
84707       {
84708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84709       };
84710     } catch (...) {
84711       {
84712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84713       };
84714     }
84715   }
84716
84717   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84718
84719   //argout typemap for const std::string&
84720
84721   return jresult;
84722 }
84723
84724
84725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
84726   void * jresult ;
84727   Dali::Toolkit::TextLabel *result = 0 ;
84728
84729   {
84730     try {
84731       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
84732     } catch (std::out_of_range& e) {
84733       {
84734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84735       };
84736     } catch (std::exception& e) {
84737       {
84738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84739       };
84740     } catch (Dali::DaliException e) {
84741       {
84742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84743       };
84744     } catch (...) {
84745       {
84746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84747       };
84748     }
84749   }
84750
84751   jresult = (void *)result;
84752   return jresult;
84753 }
84754
84755
84756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
84757   void * jresult ;
84758   Dali::Toolkit::TextLabel *arg1 = 0 ;
84759   Dali::Toolkit::TextLabel *result = 0 ;
84760
84761   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84762   if (!arg1) {
84763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84764     return 0;
84765   }
84766   {
84767     try {
84768       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
84769     } catch (std::out_of_range& e) {
84770       {
84771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (std::exception& e) {
84774       {
84775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (Dali::DaliException e) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84780       };
84781     } catch (...) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84784       };
84785     }
84786   }
84787
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
84794   void * jresult ;
84795   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84796   Dali::Toolkit::TextLabel *arg2 = 0 ;
84797   Dali::Toolkit::TextLabel *result = 0 ;
84798
84799   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84800   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84801   if (!arg2) {
84802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84803     return 0;
84804   }
84805   {
84806     try {
84807       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84808     } catch (std::out_of_range& e) {
84809       {
84810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (std::exception& e) {
84813       {
84814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84815       };
84816     } catch (Dali::DaliException e) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84819       };
84820     } catch (...) {
84821       {
84822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84823       };
84824     }
84825   }
84826
84827   jresult = (void *)result;
84828   return jresult;
84829 }
84830
84831
84832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84833   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84834
84835   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84836   {
84837     try {
84838       delete arg1;
84839     } catch (std::out_of_range& e) {
84840       {
84841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84842       };
84843     } catch (std::exception& e) {
84844       {
84845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84846       };
84847     } catch (Dali::DaliException e) {
84848       {
84849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84850       };
84851     } catch (...) {
84852       {
84853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84854       };
84855     }
84856   }
84857
84858 }
84859
84860
84861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84862   void * jresult ;
84863   Dali::BaseHandle arg1 ;
84864   Dali::BaseHandle *argp1 ;
84865   Dali::Toolkit::TextLabel result;
84866
84867   argp1 = (Dali::BaseHandle *)jarg1;
84868   if (!argp1) {
84869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84870     return 0;
84871   }
84872   arg1 = *argp1;
84873   {
84874     try {
84875       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (Dali::DaliException e) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84891       };
84892     }
84893   }
84894
84895   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84896   return jresult;
84897 }
84898
84899
84900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84901   void * jresult ;
84902   Dali::Toolkit::AccessibilityManager *result = 0 ;
84903
84904   {
84905     try {
84906       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84907     } catch (std::out_of_range& e) {
84908       {
84909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84910       };
84911     } catch (std::exception& e) {
84912       {
84913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84914       };
84915     } catch (Dali::DaliException e) {
84916       {
84917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84918       };
84919     } catch (...) {
84920       {
84921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84922       };
84923     }
84924   }
84925
84926   jresult = (void *)result;
84927   return jresult;
84928 }
84929
84930
84931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84933
84934   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84935   {
84936     try {
84937       delete arg1;
84938     } catch (std::out_of_range& e) {
84939       {
84940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84941       };
84942     } catch (std::exception& e) {
84943       {
84944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84945       };
84946     } catch (Dali::DaliException e) {
84947       {
84948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84949       };
84950     } catch (...) {
84951       {
84952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84953       };
84954     }
84955   }
84956
84957 }
84958
84959
84960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84961   void * jresult ;
84962   Dali::Toolkit::AccessibilityManager result;
84963
84964   {
84965     try {
84966       result = Dali::Toolkit::AccessibilityManager::Get();
84967     } catch (std::out_of_range& e) {
84968       {
84969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84970       };
84971     } catch (std::exception& e) {
84972       {
84973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84974       };
84975     } catch (Dali::DaliException e) {
84976       {
84977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84978       };
84979     } catch (...) {
84980       {
84981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84982       };
84983     }
84984   }
84985
84986   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84987   return jresult;
84988 }
84989
84990
84991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84992   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84993   Dali::Actor arg2 ;
84994   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84995   std::string *arg4 = 0 ;
84996   Dali::Actor *argp2 ;
84997
84998   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84999   argp2 = (Dali::Actor *)jarg2;
85000   if (!argp2) {
85001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85002     return ;
85003   }
85004   arg2 = *argp2;
85005   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85006   if (!jarg4) {
85007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85008     return ;
85009   }
85010   std::string arg4_str(jarg4);
85011   arg4 = &arg4_str;
85012   {
85013     try {
85014       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
85015     } catch (std::out_of_range& e) {
85016       {
85017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85018       };
85019     } catch (std::exception& e) {
85020       {
85021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85022       };
85023     } catch (Dali::DaliException e) {
85024       {
85025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85026       };
85027     } catch (...) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85030       };
85031     }
85032   }
85033
85034
85035   //argout typemap for const std::string&
85036
85037 }
85038
85039
85040 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
85041   char * jresult ;
85042   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85043   Dali::Actor arg2 ;
85044   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
85045   Dali::Actor *argp2 ;
85046   std::string result;
85047
85048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85049   argp2 = (Dali::Actor *)jarg2;
85050   if (!argp2) {
85051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85052     return 0;
85053   }
85054   arg2 = *argp2;
85055   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
85056   {
85057     try {
85058       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
85059     } catch (std::out_of_range& e) {
85060       {
85061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (std::exception& e) {
85064       {
85065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (Dali::DaliException e) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85070       };
85071     } catch (...) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85074       };
85075     }
85076   }
85077
85078   jresult = SWIG_csharp_string_callback((&result)->c_str());
85079   return jresult;
85080 }
85081
85082
85083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
85084   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85085   Dali::Actor arg2 ;
85086   unsigned int arg3 ;
85087   Dali::Actor *argp2 ;
85088
85089   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85090   argp2 = (Dali::Actor *)jarg2;
85091   if (!argp2) {
85092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85093     return ;
85094   }
85095   arg2 = *argp2;
85096   arg3 = (unsigned int)jarg3;
85097   {
85098     try {
85099       (arg1)->SetFocusOrder(arg2,arg3);
85100     } catch (std::out_of_range& e) {
85101       {
85102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85103       };
85104     } catch (std::exception& e) {
85105       {
85106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85107       };
85108     } catch (Dali::DaliException e) {
85109       {
85110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85111       };
85112     } catch (...) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85115       };
85116     }
85117   }
85118
85119 }
85120
85121
85122 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
85123   unsigned int jresult ;
85124   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85125   Dali::Actor arg2 ;
85126   Dali::Actor *argp2 ;
85127   unsigned int result;
85128
85129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85130   argp2 = (Dali::Actor *)jarg2;
85131   if (!argp2) {
85132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85133     return 0;
85134   }
85135   arg2 = *argp2;
85136   {
85137     try {
85138       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
85139     } catch (std::out_of_range& e) {
85140       {
85141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85142       };
85143     } catch (std::exception& e) {
85144       {
85145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85146       };
85147     } catch (Dali::DaliException e) {
85148       {
85149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85150       };
85151     } catch (...) {
85152       {
85153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85154       };
85155     }
85156   }
85157
85158   jresult = result;
85159   return jresult;
85160 }
85161
85162
85163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
85164   unsigned int jresult ;
85165   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85166   unsigned int result;
85167
85168   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85169   {
85170     try {
85171       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
85172     } catch (std::out_of_range& e) {
85173       {
85174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85175       };
85176     } catch (std::exception& e) {
85177       {
85178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85179       };
85180     } catch (Dali::DaliException e) {
85181       {
85182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85183       };
85184     } catch (...) {
85185       {
85186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85187       };
85188     }
85189   }
85190
85191   jresult = result;
85192   return jresult;
85193 }
85194
85195
85196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
85197   void * jresult ;
85198   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85199   unsigned int arg2 ;
85200   Dali::Actor result;
85201
85202   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85203   arg2 = (unsigned int)jarg2;
85204   {
85205     try {
85206       result = (arg1)->GetActorByFocusOrder(arg2);
85207     } catch (std::out_of_range& e) {
85208       {
85209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85210       };
85211     } catch (std::exception& e) {
85212       {
85213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85214       };
85215     } catch (Dali::DaliException e) {
85216       {
85217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85218       };
85219     } catch (...) {
85220       {
85221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85222       };
85223     }
85224   }
85225
85226   jresult = new Dali::Actor((const Dali::Actor &)result);
85227   return jresult;
85228 }
85229
85230
85231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
85232   unsigned int jresult ;
85233   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85234   Dali::Actor arg2 ;
85235   Dali::Actor *argp2 ;
85236   bool result;
85237
85238   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85239   argp2 = (Dali::Actor *)jarg2;
85240   if (!argp2) {
85241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85242     return 0;
85243   }
85244   arg2 = *argp2;
85245   {
85246     try {
85247       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
85248     } catch (std::out_of_range& e) {
85249       {
85250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85251       };
85252     } catch (std::exception& e) {
85253       {
85254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85255       };
85256     } catch (Dali::DaliException e) {
85257       {
85258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85259       };
85260     } catch (...) {
85261       {
85262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85263       };
85264     }
85265   }
85266
85267   jresult = result;
85268   return jresult;
85269 }
85270
85271
85272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
85273   void * jresult ;
85274   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85275   Dali::Actor result;
85276
85277   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85278   {
85279     try {
85280       result = (arg1)->GetCurrentFocusActor();
85281     } catch (std::out_of_range& e) {
85282       {
85283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85284       };
85285     } catch (std::exception& e) {
85286       {
85287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85288       };
85289     } catch (Dali::DaliException e) {
85290       {
85291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85292       };
85293     } catch (...) {
85294       {
85295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85296       };
85297     }
85298   }
85299
85300   jresult = new Dali::Actor((const Dali::Actor &)result);
85301   return jresult;
85302 }
85303
85304
85305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
85306   void * jresult ;
85307   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85308   Dali::Actor result;
85309
85310   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85311   {
85312     try {
85313       result = (arg1)->GetCurrentFocusGroup();
85314     } catch (std::out_of_range& e) {
85315       {
85316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85317       };
85318     } catch (std::exception& e) {
85319       {
85320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85321       };
85322     } catch (Dali::DaliException e) {
85323       {
85324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85325       };
85326     } catch (...) {
85327       {
85328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85329       };
85330     }
85331   }
85332
85333   jresult = new Dali::Actor((const Dali::Actor &)result);
85334   return jresult;
85335 }
85336
85337
85338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
85339   unsigned int jresult ;
85340   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85341   unsigned int result;
85342
85343   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85344   {
85345     try {
85346       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
85347     } catch (std::out_of_range& e) {
85348       {
85349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85350       };
85351     } catch (std::exception& e) {
85352       {
85353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85354       };
85355     } catch (Dali::DaliException e) {
85356       {
85357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85358       };
85359     } catch (...) {
85360       {
85361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85362       };
85363     }
85364   }
85365
85366   jresult = result;
85367   return jresult;
85368 }
85369
85370
85371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
85372   unsigned int jresult ;
85373   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85374   bool result;
85375
85376   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85377   {
85378     try {
85379       result = (bool)(arg1)->MoveFocusForward();
85380     } catch (std::out_of_range& e) {
85381       {
85382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85383       };
85384     } catch (std::exception& e) {
85385       {
85386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85387       };
85388     } catch (Dali::DaliException e) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85391       };
85392     } catch (...) {
85393       {
85394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85395       };
85396     }
85397   }
85398
85399   jresult = result;
85400   return jresult;
85401 }
85402
85403
85404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
85405   unsigned int jresult ;
85406   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85407   bool result;
85408
85409   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85410   {
85411     try {
85412       result = (bool)(arg1)->MoveFocusBackward();
85413     } catch (std::out_of_range& e) {
85414       {
85415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85416       };
85417     } catch (std::exception& e) {
85418       {
85419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85420       };
85421     } catch (Dali::DaliException e) {
85422       {
85423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85424       };
85425     } catch (...) {
85426       {
85427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85428       };
85429     }
85430   }
85431
85432   jresult = result;
85433   return jresult;
85434 }
85435
85436
85437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
85438   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85439
85440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85441   {
85442     try {
85443       (arg1)->ClearFocus();
85444     } catch (std::out_of_range& e) {
85445       {
85446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85447       };
85448     } catch (std::exception& e) {
85449       {
85450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85451       };
85452     } catch (Dali::DaliException e) {
85453       {
85454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85455       };
85456     } catch (...) {
85457       {
85458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85459       };
85460     }
85461   }
85462
85463 }
85464
85465
85466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
85467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85468
85469   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85470   {
85471     try {
85472       (arg1)->Reset();
85473     } catch (std::out_of_range& e) {
85474       {
85475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85476       };
85477     } catch (std::exception& e) {
85478       {
85479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85480       };
85481     } catch (Dali::DaliException e) {
85482       {
85483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85484       };
85485     } catch (...) {
85486       {
85487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85488       };
85489     }
85490   }
85491
85492 }
85493
85494
85495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
85496   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85497   Dali::Actor arg2 ;
85498   bool arg3 ;
85499   Dali::Actor *argp2 ;
85500
85501   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85502   argp2 = (Dali::Actor *)jarg2;
85503   if (!argp2) {
85504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85505     return ;
85506   }
85507   arg2 = *argp2;
85508   arg3 = jarg3 ? true : false;
85509   {
85510     try {
85511       (arg1)->SetFocusGroup(arg2,arg3);
85512     } catch (std::out_of_range& e) {
85513       {
85514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85515       };
85516     } catch (std::exception& e) {
85517       {
85518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85519       };
85520     } catch (Dali::DaliException e) {
85521       {
85522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85523       };
85524     } catch (...) {
85525       {
85526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85527       };
85528     }
85529   }
85530
85531 }
85532
85533
85534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
85535   unsigned int jresult ;
85536   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85537   Dali::Actor arg2 ;
85538   Dali::Actor *argp2 ;
85539   bool result;
85540
85541   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85542   argp2 = (Dali::Actor *)jarg2;
85543   if (!argp2) {
85544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85545     return 0;
85546   }
85547   arg2 = *argp2;
85548   {
85549     try {
85550       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85558       };
85559     } catch (Dali::DaliException e) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85562       };
85563     } catch (...) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85566       };
85567     }
85568   }
85569
85570   jresult = result;
85571   return jresult;
85572 }
85573
85574
85575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
85576   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85577   bool arg2 ;
85578
85579   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85580   arg2 = jarg2 ? true : false;
85581   {
85582     try {
85583       (arg1)->SetGroupMode(arg2);
85584     } catch (std::out_of_range& e) {
85585       {
85586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85587       };
85588     } catch (std::exception& e) {
85589       {
85590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85591       };
85592     } catch (Dali::DaliException e) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85599       };
85600     }
85601   }
85602
85603 }
85604
85605
85606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
85607   unsigned int jresult ;
85608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85609   bool result;
85610
85611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85612   {
85613     try {
85614       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
85615     } catch (std::out_of_range& e) {
85616       {
85617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85618       };
85619     } catch (std::exception& e) {
85620       {
85621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (Dali::DaliException e) {
85624       {
85625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85626       };
85627     } catch (...) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85630       };
85631     }
85632   }
85633
85634   jresult = result;
85635   return jresult;
85636 }
85637
85638
85639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
85640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85641   bool arg2 ;
85642
85643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85644   arg2 = jarg2 ? true : false;
85645   {
85646     try {
85647       (arg1)->SetWrapMode(arg2);
85648     } catch (std::out_of_range& e) {
85649       {
85650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85651       };
85652     } catch (std::exception& e) {
85653       {
85654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85655       };
85656     } catch (Dali::DaliException e) {
85657       {
85658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85659       };
85660     } catch (...) {
85661       {
85662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85663       };
85664     }
85665   }
85666
85667 }
85668
85669
85670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
85671   unsigned int jresult ;
85672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85673   bool result;
85674
85675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85676   {
85677     try {
85678       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (Dali::DaliException e) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85694       };
85695     }
85696   }
85697
85698   jresult = result;
85699   return jresult;
85700 }
85701
85702
85703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
85704   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85705   Dali::Actor arg2 ;
85706   Dali::Actor *argp2 ;
85707
85708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85709   argp2 = (Dali::Actor *)jarg2;
85710   if (!argp2) {
85711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85712     return ;
85713   }
85714   arg2 = *argp2;
85715   {
85716     try {
85717       (arg1)->SetFocusIndicatorActor(arg2);
85718     } catch (std::out_of_range& e) {
85719       {
85720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85721       };
85722     } catch (std::exception& e) {
85723       {
85724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85725       };
85726     } catch (Dali::DaliException e) {
85727       {
85728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85729       };
85730     } catch (...) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85733       };
85734     }
85735   }
85736
85737 }
85738
85739
85740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
85741   void * jresult ;
85742   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85743   Dali::Actor result;
85744
85745   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85746   {
85747     try {
85748       result = (arg1)->GetFocusIndicatorActor();
85749     } catch (std::out_of_range& e) {
85750       {
85751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (std::exception& e) {
85754       {
85755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85756       };
85757     } catch (Dali::DaliException e) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85760       };
85761     } catch (...) {
85762       {
85763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85764       };
85765     }
85766   }
85767
85768   jresult = new Dali::Actor((const Dali::Actor &)result);
85769   return jresult;
85770 }
85771
85772
85773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
85774   void * jresult ;
85775   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85776   Dali::Actor arg2 ;
85777   Dali::Actor *argp2 ;
85778   Dali::Actor result;
85779
85780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85781   argp2 = (Dali::Actor *)jarg2;
85782   if (!argp2) {
85783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85784     return 0;
85785   }
85786   arg2 = *argp2;
85787   {
85788     try {
85789       result = (arg1)->GetFocusGroup(arg2);
85790     } catch (std::out_of_range& e) {
85791       {
85792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85793       };
85794     } catch (std::exception& e) {
85795       {
85796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85797       };
85798     } catch (Dali::DaliException e) {
85799       {
85800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85801       };
85802     } catch (...) {
85803       {
85804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85805       };
85806     }
85807   }
85808
85809   jresult = new Dali::Actor((const Dali::Actor &)result);
85810   return jresult;
85811 }
85812
85813
85814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85815   void * jresult ;
85816   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85817   Dali::Vector2 result;
85818
85819   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85820   {
85821     try {
85822       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85823     } catch (std::out_of_range& e) {
85824       {
85825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85826       };
85827     } catch (std::exception& e) {
85828       {
85829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85830       };
85831     } catch (Dali::DaliException e) {
85832       {
85833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85834       };
85835     } catch (...) {
85836       {
85837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85838       };
85839     }
85840   }
85841
85842   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85843   return jresult;
85844 }
85845
85846
85847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85848   void * jresult ;
85849   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85850   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85851
85852   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85853   {
85854     try {
85855       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85856     } catch (std::out_of_range& e) {
85857       {
85858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85859       };
85860     } catch (std::exception& e) {
85861       {
85862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85863       };
85864     } catch (Dali::DaliException e) {
85865       {
85866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85867       };
85868     } catch (...) {
85869       {
85870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85871       };
85872     }
85873   }
85874
85875   jresult = (void *)result;
85876   return jresult;
85877 }
85878
85879
85880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85881   void * jresult ;
85882   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85883   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85884
85885   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85886   {
85887     try {
85888       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85889     } catch (std::out_of_range& e) {
85890       {
85891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85892       };
85893     } catch (std::exception& e) {
85894       {
85895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85896       };
85897     } catch (Dali::DaliException e) {
85898       {
85899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85900       };
85901     } catch (...) {
85902       {
85903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85904       };
85905     }
85906   }
85907
85908   jresult = (void *)result;
85909   return jresult;
85910 }
85911
85912
85913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85914   void * jresult ;
85915   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85916   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85917
85918   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85919   {
85920     try {
85921       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85922     } catch (std::out_of_range& e) {
85923       {
85924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85925       };
85926     } catch (std::exception& e) {
85927       {
85928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85929       };
85930     } catch (Dali::DaliException e) {
85931       {
85932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85933       };
85934     } catch (...) {
85935       {
85936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85937       };
85938     }
85939   }
85940
85941   jresult = (void *)result;
85942   return jresult;
85943 }
85944
85945
85946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85947   void * jresult ;
85948   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85949   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85950
85951   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85952   {
85953     try {
85954       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85955     } catch (std::out_of_range& e) {
85956       {
85957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85958       };
85959     } catch (std::exception& e) {
85960       {
85961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (Dali::DaliException e) {
85964       {
85965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85966       };
85967     } catch (...) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85970       };
85971     }
85972   }
85973
85974   jresult = (void *)result;
85975   return jresult;
85976 }
85977
85978
85979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85980   void * jresult ;
85981   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85982   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85983
85984   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85985   {
85986     try {
85987       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85988     } catch (std::out_of_range& e) {
85989       {
85990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85991       };
85992     } catch (std::exception& e) {
85993       {
85994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85995       };
85996     } catch (Dali::DaliException e) {
85997       {
85998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85999       };
86000     } catch (...) {
86001       {
86002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86003       };
86004     }
86005   }
86006
86007   jresult = (void *)result;
86008   return jresult;
86009 }
86010
86011
86012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
86013   void * jresult ;
86014   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86015   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86016
86017   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86018   {
86019     try {
86020       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
86021     } catch (std::out_of_range& e) {
86022       {
86023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86024       };
86025     } catch (std::exception& e) {
86026       {
86027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86028       };
86029     } catch (Dali::DaliException e) {
86030       {
86031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86032       };
86033     } catch (...) {
86034       {
86035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86036       };
86037     }
86038   }
86039
86040   jresult = (void *)result;
86041   return jresult;
86042 }
86043
86044
86045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
86046   void * jresult ;
86047   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86048   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86049
86050   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86051   {
86052     try {
86053       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
86054     } catch (std::out_of_range& e) {
86055       {
86056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86057       };
86058     } catch (std::exception& e) {
86059       {
86060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86061       };
86062     } catch (Dali::DaliException e) {
86063       {
86064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86065       };
86066     } catch (...) {
86067       {
86068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86069       };
86070     }
86071   }
86072
86073   jresult = (void *)result;
86074   return jresult;
86075 }
86076
86077
86078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
86079   void * jresult ;
86080   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86081   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86082
86083   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86084   {
86085     try {
86086       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
86087     } catch (std::out_of_range& e) {
86088       {
86089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86090       };
86091     } catch (std::exception& e) {
86092       {
86093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86094       };
86095     } catch (Dali::DaliException e) {
86096       {
86097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86098       };
86099     } catch (...) {
86100       {
86101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86102       };
86103     }
86104   }
86105
86106   jresult = (void *)result;
86107   return jresult;
86108 }
86109
86110
86111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
86112   void * jresult ;
86113   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86114   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86115
86116   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86117   {
86118     try {
86119       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
86120     } catch (std::out_of_range& e) {
86121       {
86122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86123       };
86124     } catch (std::exception& e) {
86125       {
86126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86127       };
86128     } catch (Dali::DaliException e) {
86129       {
86130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86131       };
86132     } catch (...) {
86133       {
86134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86135       };
86136     }
86137   }
86138
86139   jresult = (void *)result;
86140   return jresult;
86141 }
86142
86143
86144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
86145   void * jresult ;
86146   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86147   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86148
86149   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86150   {
86151     try {
86152       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
86153     } catch (std::out_of_range& e) {
86154       {
86155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86156       };
86157     } catch (std::exception& e) {
86158       {
86159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86160       };
86161     } catch (Dali::DaliException e) {
86162       {
86163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86164       };
86165     } catch (...) {
86166       {
86167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86168       };
86169     }
86170   }
86171
86172   jresult = (void *)result;
86173   return jresult;
86174 }
86175
86176
86177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
86178   void * jresult ;
86179   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86180   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86181
86182   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86183   {
86184     try {
86185       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
86186     } catch (std::out_of_range& e) {
86187       {
86188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86189       };
86190     } catch (std::exception& e) {
86191       {
86192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86193       };
86194     } catch (Dali::DaliException e) {
86195       {
86196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86197       };
86198     } catch (...) {
86199       {
86200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86201       };
86202     }
86203   }
86204
86205   jresult = (void *)result;
86206   return jresult;
86207 }
86208
86209
86210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
86211   void * jresult ;
86212   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86213   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86214
86215   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86216   {
86217     try {
86218       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
86219     } catch (std::out_of_range& e) {
86220       {
86221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86222       };
86223     } catch (std::exception& e) {
86224       {
86225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86226       };
86227     } catch (Dali::DaliException e) {
86228       {
86229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86230       };
86231     } catch (...) {
86232       {
86233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86234       };
86235     }
86236   }
86237
86238   jresult = (void *)result;
86239   return jresult;
86240 }
86241
86242
86243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
86244   void * jresult ;
86245   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86246   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86247
86248   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86249   {
86250     try {
86251       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
86252     } catch (std::out_of_range& e) {
86253       {
86254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86255       };
86256     } catch (std::exception& e) {
86257       {
86258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (Dali::DaliException e) {
86261       {
86262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86263       };
86264     } catch (...) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86267       };
86268     }
86269   }
86270
86271   jresult = (void *)result;
86272   return jresult;
86273 }
86274
86275
86276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
86277   void * jresult ;
86278   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86279   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86280
86281   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86282   {
86283     try {
86284       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
86285     } catch (std::out_of_range& e) {
86286       {
86287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86288       };
86289     } catch (std::exception& e) {
86290       {
86291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86292       };
86293     } catch (Dali::DaliException e) {
86294       {
86295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86296       };
86297     } catch (...) {
86298       {
86299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86300       };
86301     }
86302   }
86303
86304   jresult = (void *)result;
86305   return jresult;
86306 }
86307
86308
86309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
86310   void * jresult ;
86311   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86312   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86313
86314   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86315   {
86316     try {
86317       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
86318     } catch (std::out_of_range& e) {
86319       {
86320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (std::exception& e) {
86323       {
86324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (Dali::DaliException e) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86329       };
86330     } catch (...) {
86331       {
86332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86333       };
86334     }
86335   }
86336
86337   jresult = (void *)result;
86338   return jresult;
86339 }
86340
86341
86342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
86343   void * jresult ;
86344   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86345   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86346
86347   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86348   {
86349     try {
86350       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
86351     } catch (std::out_of_range& e) {
86352       {
86353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86354       };
86355     } catch (std::exception& e) {
86356       {
86357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86358       };
86359     } catch (Dali::DaliException e) {
86360       {
86361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86362       };
86363     } catch (...) {
86364       {
86365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86366       };
86367     }
86368   }
86369
86370   jresult = (void *)result;
86371   return jresult;
86372 }
86373
86374
86375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
86376   void * jresult ;
86377   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86378   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86379
86380   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86381   {
86382     try {
86383       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
86384     } catch (std::out_of_range& e) {
86385       {
86386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86387       };
86388     } catch (std::exception& e) {
86389       {
86390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (Dali::DaliException e) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86395       };
86396     } catch (...) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86399       };
86400     }
86401   }
86402
86403   jresult = (void *)result;
86404   return jresult;
86405 }
86406
86407
86408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
86409   void * jresult ;
86410   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86411   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86412
86413   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86414   {
86415     try {
86416       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
86417     } catch (std::out_of_range& e) {
86418       {
86419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86420       };
86421     } catch (std::exception& e) {
86422       {
86423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (Dali::DaliException e) {
86426       {
86427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86428       };
86429     } catch (...) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86432       };
86433     }
86434   }
86435
86436   jresult = (void *)result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
86442   void * jresult ;
86443   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86444   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86445
86446   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86447   {
86448     try {
86449       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
86450     } catch (std::out_of_range& e) {
86451       {
86452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86453       };
86454     } catch (std::exception& e) {
86455       {
86456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86457       };
86458     } catch (Dali::DaliException e) {
86459       {
86460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86461       };
86462     } catch (...) {
86463       {
86464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86465       };
86466     }
86467   }
86468
86469   jresult = (void *)result;
86470   return jresult;
86471 }
86472
86473
86474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
86475   void * jresult ;
86476   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86477   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86478
86479   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86480   {
86481     try {
86482       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
86483     } catch (std::out_of_range& e) {
86484       {
86485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86486       };
86487     } catch (std::exception& e) {
86488       {
86489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (Dali::DaliException e) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86494       };
86495     } catch (...) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86498       };
86499     }
86500   }
86501
86502   jresult = (void *)result;
86503   return jresult;
86504 }
86505
86506
86507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
86508   void * jresult ;
86509   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86510   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86511
86512   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86513   {
86514     try {
86515       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
86516     } catch (std::out_of_range& e) {
86517       {
86518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86519       };
86520     } catch (std::exception& e) {
86521       {
86522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86523       };
86524     } catch (Dali::DaliException e) {
86525       {
86526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86527       };
86528     } catch (...) {
86529       {
86530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86531       };
86532     }
86533   }
86534
86535   jresult = (void *)result;
86536   return jresult;
86537 }
86538
86539
86540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
86541   void * jresult ;
86542   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86543   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86544
86545   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86546   {
86547     try {
86548       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
86549     } catch (std::out_of_range& e) {
86550       {
86551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86552       };
86553     } catch (std::exception& e) {
86554       {
86555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86556       };
86557     } catch (Dali::DaliException e) {
86558       {
86559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86560       };
86561     } catch (...) {
86562       {
86563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86564       };
86565     }
86566   }
86567
86568   jresult = (void *)result;
86569   return jresult;
86570 }
86571
86572
86573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
86574   void * jresult ;
86575   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86576   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86577
86578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86579   {
86580     try {
86581       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
86582     } catch (std::out_of_range& e) {
86583       {
86584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86585       };
86586     } catch (std::exception& e) {
86587       {
86588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86589       };
86590     } catch (Dali::DaliException e) {
86591       {
86592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86593       };
86594     } catch (...) {
86595       {
86596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86597       };
86598     }
86599   }
86600
86601   jresult = (void *)result;
86602   return jresult;
86603 }
86604
86605
86606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
86607   void * jresult ;
86608   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86609   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86610
86611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86612   {
86613     try {
86614       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
86615     } catch (std::out_of_range& e) {
86616       {
86617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86618       };
86619     } catch (std::exception& e) {
86620       {
86621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86622       };
86623     } catch (Dali::DaliException e) {
86624       {
86625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86626       };
86627     } catch (...) {
86628       {
86629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86630       };
86631     }
86632   }
86633
86634   jresult = (void *)result;
86635   return jresult;
86636 }
86637
86638
86639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
86640   void * jresult ;
86641   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86642   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86643
86644   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86645   {
86646     try {
86647       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
86648     } catch (std::out_of_range& e) {
86649       {
86650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86651       };
86652     } catch (std::exception& e) {
86653       {
86654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86655       };
86656     } catch (Dali::DaliException e) {
86657       {
86658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86659       };
86660     } catch (...) {
86661       {
86662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86663       };
86664     }
86665   }
86666
86667   jresult = (void *)result;
86668   return jresult;
86669 }
86670
86671
86672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
86673   void * jresult ;
86674   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86675   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86676
86677   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86678   {
86679     try {
86680       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
86681     } catch (std::out_of_range& e) {
86682       {
86683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86684       };
86685     } catch (std::exception& e) {
86686       {
86687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86688       };
86689     } catch (Dali::DaliException e) {
86690       {
86691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86692       };
86693     } catch (...) {
86694       {
86695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86696       };
86697     }
86698   }
86699
86700   jresult = (void *)result;
86701   return jresult;
86702 }
86703
86704
86705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
86706   void * jresult ;
86707   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86708   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86709
86710   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86711   {
86712     try {
86713       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
86714     } catch (std::out_of_range& e) {
86715       {
86716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86717       };
86718     } catch (std::exception& e) {
86719       {
86720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86721       };
86722     } catch (Dali::DaliException e) {
86723       {
86724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86725       };
86726     } catch (...) {
86727       {
86728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86729       };
86730     }
86731   }
86732
86733   jresult = (void *)result;
86734   return jresult;
86735 }
86736
86737
86738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
86739   void * jresult ;
86740   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86741   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86742
86743   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86744   {
86745     try {
86746       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
86747     } catch (std::out_of_range& e) {
86748       {
86749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86750       };
86751     } catch (std::exception& e) {
86752       {
86753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86754       };
86755     } catch (Dali::DaliException e) {
86756       {
86757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86758       };
86759     } catch (...) {
86760       {
86761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86762       };
86763     }
86764   }
86765
86766   jresult = (void *)result;
86767   return jresult;
86768 }
86769
86770
86771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
86772   void * jresult ;
86773   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86774   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
86775
86776   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86777   {
86778     try {
86779       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
86780     } catch (std::out_of_range& e) {
86781       {
86782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86783       };
86784     } catch (std::exception& e) {
86785       {
86786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86787       };
86788     } catch (Dali::DaliException e) {
86789       {
86790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86791       };
86792     } catch (...) {
86793       {
86794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86795       };
86796     }
86797   }
86798
86799   jresult = (void *)result;
86800   return jresult;
86801 }
86802
86803
86804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86805   void * jresult ;
86806   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86807   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86808
86809   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86810   {
86811     try {
86812       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86813     } catch (std::out_of_range& e) {
86814       {
86815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86816       };
86817     } catch (std::exception& e) {
86818       {
86819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86820       };
86821     } catch (Dali::DaliException e) {
86822       {
86823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86824       };
86825     } catch (...) {
86826       {
86827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86828       };
86829     }
86830   }
86831
86832   jresult = (void *)result;
86833   return jresult;
86834 }
86835
86836
86837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86838   void * jresult ;
86839   Dali::Toolkit::StyleManager *result = 0 ;
86840
86841   {
86842     try {
86843       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86844     } catch (std::out_of_range& e) {
86845       {
86846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86847       };
86848     } catch (std::exception& e) {
86849       {
86850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86851       };
86852     } catch (Dali::DaliException e) {
86853       {
86854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86855       };
86856     } catch (...) {
86857       {
86858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86859       };
86860     }
86861   }
86862
86863   jresult = (void *)result;
86864   return jresult;
86865 }
86866
86867
86868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86869   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86870
86871   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86872   {
86873     try {
86874       delete arg1;
86875     } catch (std::out_of_range& e) {
86876       {
86877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86878       };
86879     } catch (std::exception& e) {
86880       {
86881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86882       };
86883     } catch (Dali::DaliException e) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86886       };
86887     } catch (...) {
86888       {
86889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86890       };
86891     }
86892   }
86893
86894 }
86895
86896
86897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86898   void * jresult ;
86899   Dali::Toolkit::StyleManager result;
86900
86901   {
86902     try {
86903       result = Dali::Toolkit::StyleManager::Get();
86904     } catch (std::out_of_range& e) {
86905       {
86906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86907       };
86908     } catch (std::exception& e) {
86909       {
86910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86911       };
86912     } catch (Dali::DaliException e) {
86913       {
86914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86915       };
86916     } catch (...) {
86917       {
86918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86919       };
86920     }
86921   }
86922
86923   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86924   return jresult;
86925 }
86926
86927
86928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86929   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86930   std::string *arg2 = 0 ;
86931
86932   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86933   if (!jarg2) {
86934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86935     return ;
86936   }
86937   std::string arg2_str(jarg2);
86938   arg2 = &arg2_str;
86939   {
86940     try {
86941       (arg1)->ApplyTheme((std::string const &)*arg2);
86942     } catch (std::out_of_range& e) {
86943       {
86944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86945       };
86946     } catch (std::exception& e) {
86947       {
86948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86949       };
86950     } catch (Dali::DaliException e) {
86951       {
86952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86953       };
86954     } catch (...) {
86955       {
86956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86957       };
86958     }
86959   }
86960
86961
86962   //argout typemap for const std::string&
86963
86964 }
86965
86966
86967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86968   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86969
86970   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86971   {
86972     try {
86973       (arg1)->ApplyDefaultTheme();
86974     } catch (std::out_of_range& e) {
86975       {
86976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86977       };
86978     } catch (std::exception& e) {
86979       {
86980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86981       };
86982     } catch (Dali::DaliException e) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86985       };
86986     } catch (...) {
86987       {
86988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86989       };
86990     }
86991   }
86992
86993 }
86994
86995
86996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86997   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86998   std::string *arg2 = 0 ;
86999   Dali::Property::Value *arg3 = 0 ;
87000
87001   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87002   if (!jarg2) {
87003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87004     return ;
87005   }
87006   std::string arg2_str(jarg2);
87007   arg2 = &arg2_str;
87008   arg3 = (Dali::Property::Value *)jarg3;
87009   if (!arg3) {
87010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
87011     return ;
87012   }
87013   {
87014     try {
87015       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
87016     } catch (std::out_of_range& e) {
87017       {
87018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87019       };
87020     } catch (std::exception& e) {
87021       {
87022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87023       };
87024     } catch (Dali::DaliException e) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87027       };
87028     } catch (...) {
87029       {
87030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87031       };
87032     }
87033   }
87034
87035
87036   //argout typemap for const std::string&
87037
87038 }
87039
87040
87041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
87042   unsigned int jresult ;
87043   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87044   std::string *arg2 = 0 ;
87045   Dali::Property::Value *arg3 = 0 ;
87046   bool result;
87047
87048   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87049   if (!jarg2) {
87050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87051     return 0;
87052   }
87053   std::string arg2_str(jarg2);
87054   arg2 = &arg2_str;
87055   arg3 = (Dali::Property::Value *)jarg3;
87056   if (!arg3) {
87057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
87058     return 0;
87059   }
87060   {
87061     try {
87062       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
87063     } catch (std::out_of_range& e) {
87064       {
87065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87066       };
87067     } catch (std::exception& e) {
87068       {
87069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87070       };
87071     } catch (Dali::DaliException e) {
87072       {
87073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87074       };
87075     } catch (...) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87078       };
87079     }
87080   }
87081
87082   jresult = result;
87083
87084   //argout typemap for const std::string&
87085
87086   return jresult;
87087 }
87088
87089
87090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
87091   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87092   Dali::Toolkit::Control arg2 ;
87093   std::string *arg3 = 0 ;
87094   std::string *arg4 = 0 ;
87095   Dali::Toolkit::Control *argp2 ;
87096
87097   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87098   argp2 = (Dali::Toolkit::Control *)jarg2;
87099   if (!argp2) {
87100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
87101     return ;
87102   }
87103   arg2 = *argp2;
87104   if (!jarg3) {
87105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87106     return ;
87107   }
87108   std::string arg3_str(jarg3);
87109   arg3 = &arg3_str;
87110   if (!jarg4) {
87111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87112     return ;
87113   }
87114   std::string arg4_str(jarg4);
87115   arg4 = &arg4_str;
87116   {
87117     try {
87118       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
87119     } catch (std::out_of_range& e) {
87120       {
87121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87122       };
87123     } catch (std::exception& e) {
87124       {
87125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87126       };
87127     } catch (Dali::DaliException e) {
87128       {
87129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87130       };
87131     } catch (...) {
87132       {
87133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87134       };
87135     }
87136   }
87137
87138
87139   //argout typemap for const std::string&
87140
87141
87142   //argout typemap for const std::string&
87143
87144 }
87145
87146
87147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
87148   void * jresult ;
87149   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
87150   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
87151
87152   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
87153   {
87154     try {
87155       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
87156     } catch (std::out_of_range& e) {
87157       {
87158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87159       };
87160     } catch (std::exception& e) {
87161       {
87162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87163       };
87164     } catch (Dali::DaliException e) {
87165       {
87166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87167       };
87168     } catch (...) {
87169       {
87170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87171       };
87172     }
87173   }
87174
87175   jresult = (void *)result;
87176   return jresult;
87177 }
87178
87179
87180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
87181   int jresult ;
87182   int result;
87183
87184   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
87185   jresult = (int)result;
87186   return jresult;
87187 }
87188
87189
87190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
87191   int jresult ;
87192   int result;
87193
87194   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
87195   jresult = (int)result;
87196   return jresult;
87197 }
87198
87199
87200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
87201   int jresult ;
87202   int result;
87203
87204   result = (int)Dali::Toolkit::Slider::Property::VALUE;
87205   jresult = (int)result;
87206   return jresult;
87207 }
87208
87209
87210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
87211   int jresult ;
87212   int result;
87213
87214   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
87215   jresult = (int)result;
87216   return jresult;
87217 }
87218
87219
87220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
87221   int jresult ;
87222   int result;
87223
87224   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
87225   jresult = (int)result;
87226   return jresult;
87227 }
87228
87229
87230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
87231   int jresult ;
87232   int result;
87233
87234   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
87235   jresult = (int)result;
87236   return jresult;
87237 }
87238
87239
87240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
87241   int jresult ;
87242   int result;
87243
87244   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
87245   jresult = (int)result;
87246   return jresult;
87247 }
87248
87249
87250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
87251   int jresult ;
87252   int result;
87253
87254   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
87255   jresult = (int)result;
87256   return jresult;
87257 }
87258
87259
87260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
87261   int jresult ;
87262   int result;
87263
87264   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
87265   jresult = (int)result;
87266   return jresult;
87267 }
87268
87269
87270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
87271   int jresult ;
87272   int result;
87273
87274   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
87275   jresult = (int)result;
87276   return jresult;
87277 }
87278
87279
87280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
87281   int jresult ;
87282   int result;
87283
87284   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
87285   jresult = (int)result;
87286   return jresult;
87287 }
87288
87289
87290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
87291   int jresult ;
87292   int result;
87293
87294   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
87295   jresult = (int)result;
87296   return jresult;
87297 }
87298
87299
87300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
87301   int jresult ;
87302   int result;
87303
87304   result = (int)Dali::Toolkit::Slider::Property::MARKS;
87305   jresult = (int)result;
87306   return jresult;
87307 }
87308
87309
87310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
87311   int jresult ;
87312   int result;
87313
87314   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
87315   jresult = (int)result;
87316   return jresult;
87317 }
87318
87319
87320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
87321   int jresult ;
87322   int result;
87323
87324   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
87325   jresult = (int)result;
87326   return jresult;
87327 }
87328
87329
87330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
87331   void * jresult ;
87332   Dali::Toolkit::Slider::Property *result = 0 ;
87333
87334   {
87335     try {
87336       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
87337     } catch (std::out_of_range& e) {
87338       {
87339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87340       };
87341     } catch (std::exception& e) {
87342       {
87343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87344       };
87345     } catch (Dali::DaliException e) {
87346       {
87347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87348       };
87349     } catch (...) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87352       };
87353     }
87354   }
87355
87356   jresult = (void *)result;
87357   return jresult;
87358 }
87359
87360
87361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
87362   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
87363
87364   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
87365   {
87366     try {
87367       delete arg1;
87368     } catch (std::out_of_range& e) {
87369       {
87370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87371       };
87372     } catch (std::exception& e) {
87373       {
87374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87375       };
87376     } catch (Dali::DaliException e) {
87377       {
87378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87379       };
87380     } catch (...) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87383       };
87384     }
87385   }
87386
87387 }
87388
87389
87390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
87391   void * jresult ;
87392   Dali::Toolkit::Slider result;
87393
87394   {
87395     try {
87396       result = Dali::Toolkit::Slider::New();
87397     } catch (std::out_of_range& e) {
87398       {
87399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87400       };
87401     } catch (std::exception& e) {
87402       {
87403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87404       };
87405     } catch (Dali::DaliException e) {
87406       {
87407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87408       };
87409     } catch (...) {
87410       {
87411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87412       };
87413     }
87414   }
87415
87416   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87417   return jresult;
87418 }
87419
87420
87421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
87422   void * jresult ;
87423   Dali::Toolkit::Slider *result = 0 ;
87424
87425   {
87426     try {
87427       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
87428     } catch (std::out_of_range& e) {
87429       {
87430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87431       };
87432     } catch (std::exception& e) {
87433       {
87434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87435       };
87436     } catch (Dali::DaliException e) {
87437       {
87438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87439       };
87440     } catch (...) {
87441       {
87442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87443       };
87444     }
87445   }
87446
87447   jresult = (void *)result;
87448   return jresult;
87449 }
87450
87451
87452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
87453   void * jresult ;
87454   Dali::Toolkit::Slider *arg1 = 0 ;
87455   Dali::Toolkit::Slider *result = 0 ;
87456
87457   arg1 = (Dali::Toolkit::Slider *)jarg1;
87458   if (!arg1) {
87459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87460     return 0;
87461   }
87462   {
87463     try {
87464       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
87465     } catch (std::out_of_range& e) {
87466       {
87467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87468       };
87469     } catch (std::exception& e) {
87470       {
87471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87472       };
87473     } catch (Dali::DaliException e) {
87474       {
87475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87476       };
87477     } catch (...) {
87478       {
87479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87480       };
87481     }
87482   }
87483
87484   jresult = (void *)result;
87485   return jresult;
87486 }
87487
87488
87489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
87490   void * jresult ;
87491   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87492   Dali::Toolkit::Slider *arg2 = 0 ;
87493   Dali::Toolkit::Slider *result = 0 ;
87494
87495   arg1 = (Dali::Toolkit::Slider *)jarg1;
87496   arg2 = (Dali::Toolkit::Slider *)jarg2;
87497   if (!arg2) {
87498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
87499     return 0;
87500   }
87501   {
87502     try {
87503       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
87504     } catch (std::out_of_range& e) {
87505       {
87506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87507       };
87508     } catch (std::exception& e) {
87509       {
87510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87511       };
87512     } catch (Dali::DaliException e) {
87513       {
87514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87515       };
87516     } catch (...) {
87517       {
87518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87519       };
87520     }
87521   }
87522
87523   jresult = (void *)result;
87524   return jresult;
87525 }
87526
87527
87528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
87529   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87530
87531   arg1 = (Dali::Toolkit::Slider *)jarg1;
87532   {
87533     try {
87534       delete arg1;
87535     } catch (std::out_of_range& e) {
87536       {
87537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87538       };
87539     } catch (std::exception& e) {
87540       {
87541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87542       };
87543     } catch (Dali::DaliException e) {
87544       {
87545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87546       };
87547     } catch (...) {
87548       {
87549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87550       };
87551     }
87552   }
87553
87554 }
87555
87556
87557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
87558   void * jresult ;
87559   Dali::BaseHandle arg1 ;
87560   Dali::BaseHandle *argp1 ;
87561   Dali::Toolkit::Slider result;
87562
87563   argp1 = (Dali::BaseHandle *)jarg1;
87564   if (!argp1) {
87565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87566     return 0;
87567   }
87568   arg1 = *argp1;
87569   {
87570     try {
87571       result = Dali::Toolkit::Slider::DownCast(arg1);
87572     } catch (std::out_of_range& e) {
87573       {
87574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87575       };
87576     } catch (std::exception& e) {
87577       {
87578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87579       };
87580     } catch (Dali::DaliException e) {
87581       {
87582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87583       };
87584     } catch (...) {
87585       {
87586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87587       };
87588     }
87589   }
87590
87591   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
87592   return jresult;
87593 }
87594
87595
87596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
87597   void * jresult ;
87598   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87599   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87600
87601   arg1 = (Dali::Toolkit::Slider *)jarg1;
87602   {
87603     try {
87604       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
87605     } catch (std::out_of_range& e) {
87606       {
87607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87608       };
87609     } catch (std::exception& e) {
87610       {
87611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87612       };
87613     } catch (Dali::DaliException e) {
87614       {
87615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87616       };
87617     } catch (...) {
87618       {
87619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87620       };
87621     }
87622   }
87623
87624   jresult = (void *)result;
87625   return jresult;
87626 }
87627
87628
87629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
87630   void * jresult ;
87631   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87632   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
87633
87634   arg1 = (Dali::Toolkit::Slider *)jarg1;
87635   {
87636     try {
87637       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
87638     } catch (std::out_of_range& e) {
87639       {
87640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87641       };
87642     } catch (std::exception& e) {
87643       {
87644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87645       };
87646     } catch (Dali::DaliException e) {
87647       {
87648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87649       };
87650     } catch (...) {
87651       {
87652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87653       };
87654     }
87655   }
87656
87657   jresult = (void *)result;
87658   return jresult;
87659 }
87660
87661
87662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
87663   void * jresult ;
87664   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
87665   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
87666
87667   arg1 = (Dali::Toolkit::Slider *)jarg1;
87668   {
87669     try {
87670       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
87671     } catch (std::out_of_range& e) {
87672       {
87673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87674       };
87675     } catch (std::exception& e) {
87676       {
87677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87678       };
87679     } catch (Dali::DaliException e) {
87680       {
87681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87682       };
87683     } catch (...) {
87684       {
87685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87686       };
87687     }
87688   }
87689
87690   jresult = (void *)result;
87691   return jresult;
87692 }
87693
87694
87695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
87696   int jresult ;
87697   int result;
87698
87699   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
87700   jresult = (int)result;
87701   return jresult;
87702 }
87703
87704
87705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
87706   int jresult ;
87707   int result;
87708
87709   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
87710   jresult = (int)result;
87711   return jresult;
87712 }
87713
87714
87715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
87716   int jresult ;
87717   int result;
87718
87719   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
87720   jresult = (int)result;
87721   return jresult;
87722 }
87723
87724
87725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
87726   int jresult ;
87727   int result;
87728
87729   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
87730   jresult = (int)result;
87731   return jresult;
87732 }
87733
87734
87735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
87736   int result;
87737
87738   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
87739
87740   return result;
87741 }
87742
87743
87744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
87745   void * jresult ;
87746   Dali::Toolkit::VideoView::Property *result = 0 ;
87747
87748   {
87749     try {
87750       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
87751     } catch (std::out_of_range& e) {
87752       {
87753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87754       };
87755     } catch (std::exception& e) {
87756       {
87757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87758       };
87759     } catch (Dali::DaliException e) {
87760       {
87761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87762       };
87763     } catch (...) {
87764       {
87765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87766       };
87767     }
87768   }
87769
87770   jresult = (void *)result;
87771   return jresult;
87772 }
87773
87774
87775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
87776   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
87777
87778   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
87779   {
87780     try {
87781       delete arg1;
87782     } catch (std::out_of_range& e) {
87783       {
87784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87785       };
87786     } catch (std::exception& e) {
87787       {
87788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87789       };
87790     } catch (Dali::DaliException e) {
87791       {
87792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87793       };
87794     } catch (...) {
87795       {
87796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87797       };
87798     }
87799   }
87800
87801 }
87802
87803
87804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87805   void * jresult ;
87806   Dali::Toolkit::VideoView result;
87807
87808   {
87809     try {
87810       result = Dali::Toolkit::VideoView::New();
87811     } catch (std::out_of_range& e) {
87812       {
87813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87814       };
87815     } catch (std::exception& e) {
87816       {
87817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87818       };
87819     } catch (Dali::DaliException e) {
87820       {
87821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87822       };
87823     } catch (...) {
87824       {
87825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87826       };
87827     }
87828   }
87829
87830   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87831   return jresult;
87832 }
87833
87834
87835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87836   void * jresult ;
87837   std::string *arg1 = 0 ;
87838   Dali::Toolkit::VideoView result;
87839
87840   if (!jarg1) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87842     return 0;
87843   }
87844   std::string arg1_str(jarg1);
87845   arg1 = &arg1_str;
87846   {
87847     try {
87848       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87849     } catch (std::out_of_range& e) {
87850       {
87851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87852       };
87853     } catch (std::exception& e) {
87854       {
87855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (Dali::DaliException e) {
87858       {
87859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87860       };
87861     } catch (...) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87864       };
87865     }
87866   }
87867
87868   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87869
87870   //argout typemap for const std::string&
87871
87872   return jresult;
87873 }
87874
87875
87876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87877   void * jresult ;
87878   Dali::Toolkit::VideoView *result = 0 ;
87879
87880   {
87881     try {
87882       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87883     } catch (std::out_of_range& e) {
87884       {
87885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87886       };
87887     } catch (std::exception& e) {
87888       {
87889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87890       };
87891     } catch (Dali::DaliException e) {
87892       {
87893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87894       };
87895     } catch (...) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87898       };
87899     }
87900   }
87901
87902   jresult = (void *)result;
87903   return jresult;
87904 }
87905
87906
87907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87908   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87909
87910   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87911   {
87912     try {
87913       delete arg1;
87914     } catch (std::out_of_range& e) {
87915       {
87916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87917       };
87918     } catch (std::exception& e) {
87919       {
87920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87921       };
87922     } catch (Dali::DaliException e) {
87923       {
87924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87925       };
87926     } catch (...) {
87927       {
87928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87929       };
87930     }
87931   }
87932
87933 }
87934
87935
87936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87937   void * jresult ;
87938   Dali::Toolkit::VideoView *arg1 = 0 ;
87939   Dali::Toolkit::VideoView *result = 0 ;
87940
87941   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87942   if (!arg1) {
87943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87944     return 0;
87945   }
87946   {
87947     try {
87948       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87949     } catch (std::out_of_range& e) {
87950       {
87951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87952       };
87953     } catch (std::exception& e) {
87954       {
87955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87956       };
87957     } catch (Dali::DaliException e) {
87958       {
87959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87960       };
87961     } catch (...) {
87962       {
87963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87964       };
87965     }
87966   }
87967
87968   jresult = (void *)result;
87969   return jresult;
87970 }
87971
87972
87973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87974   void * jresult ;
87975   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87976   Dali::Toolkit::VideoView *arg2 = 0 ;
87977   Dali::Toolkit::VideoView *result = 0 ;
87978
87979   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87980   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87981   if (!arg2) {
87982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87983     return 0;
87984   }
87985   {
87986     try {
87987       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87988     } catch (std::out_of_range& e) {
87989       {
87990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (std::exception& e) {
87993       {
87994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87995       };
87996     } catch (Dali::DaliException e) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87999       };
88000     } catch (...) {
88001       {
88002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88003       };
88004     }
88005   }
88006
88007   jresult = (void *)result;
88008   return jresult;
88009 }
88010
88011
88012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
88013   void * jresult ;
88014   Dali::BaseHandle arg1 ;
88015   Dali::BaseHandle *argp1 ;
88016   Dali::Toolkit::VideoView result;
88017
88018   argp1 = (Dali::BaseHandle *)jarg1;
88019   if (!argp1) {
88020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88021     return 0;
88022   }
88023   arg1 = *argp1;
88024   {
88025     try {
88026       result = Dali::Toolkit::VideoView::DownCast(arg1);
88027     } catch (std::out_of_range& e) {
88028       {
88029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88030       };
88031     } catch (std::exception& e) {
88032       {
88033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88034       };
88035     } catch (Dali::DaliException e) {
88036       {
88037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88038       };
88039     } catch (...) {
88040       {
88041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88042       };
88043     }
88044   }
88045
88046   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
88047   return jresult;
88048 }
88049
88050
88051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
88052   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88053
88054   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88055   {
88056     try {
88057       (arg1)->Play();
88058     } catch (std::out_of_range& e) {
88059       {
88060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88061       };
88062     } catch (std::exception& e) {
88063       {
88064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88065       };
88066     } catch (Dali::DaliException e) {
88067       {
88068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88069       };
88070     } catch (...) {
88071       {
88072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88073       };
88074     }
88075   }
88076
88077 }
88078
88079
88080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
88081   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88082
88083   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88084   {
88085     try {
88086       (arg1)->Pause();
88087     } catch (std::out_of_range& e) {
88088       {
88089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88090       };
88091     } catch (std::exception& e) {
88092       {
88093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88094       };
88095     } catch (Dali::DaliException e) {
88096       {
88097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88098       };
88099     } catch (...) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88102       };
88103     }
88104   }
88105
88106 }
88107
88108
88109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
88110   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88111
88112   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88113   {
88114     try {
88115       (arg1)->Stop();
88116     } catch (std::out_of_range& e) {
88117       {
88118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88119       };
88120     } catch (std::exception& e) {
88121       {
88122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88123       };
88124     } catch (Dali::DaliException e) {
88125       {
88126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88127       };
88128     } catch (...) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88131       };
88132     }
88133   }
88134
88135 }
88136
88137
88138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
88139   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88140   int arg2 ;
88141
88142   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88143   arg2 = (int)jarg2;
88144   {
88145     try {
88146       (arg1)->Forward(arg2);
88147     } catch (std::out_of_range& e) {
88148       {
88149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88150       };
88151     } catch (std::exception& e) {
88152       {
88153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88154       };
88155     } catch (Dali::DaliException e) {
88156       {
88157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88158       };
88159     } catch (...) {
88160       {
88161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88162       };
88163     }
88164   }
88165
88166 }
88167
88168
88169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
88170   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88171   int arg2 ;
88172
88173   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88174   arg2 = (int)jarg2;
88175   {
88176     try {
88177       (arg1)->Backward(arg2);
88178     } catch (std::out_of_range& e) {
88179       {
88180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88181       };
88182     } catch (std::exception& e) {
88183       {
88184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88185       };
88186     } catch (Dali::DaliException e) {
88187       {
88188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88189       };
88190     } catch (...) {
88191       {
88192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88193       };
88194     }
88195   }
88196
88197 }
88198
88199
88200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
88201   void * jresult ;
88202   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
88203   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
88204
88205   arg1 = (Dali::Toolkit::VideoView *)jarg1;
88206   {
88207     try {
88208       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
88209     } catch (std::out_of_range& e) {
88210       {
88211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88212       };
88213     } catch (std::exception& e) {
88214       {
88215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88216       };
88217     } catch (Dali::DaliException e) {
88218       {
88219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88220       };
88221     } catch (...) {
88222       {
88223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88224       };
88225     }
88226   }
88227
88228   jresult = (void *)result;
88229   return jresult;
88230 }
88231
88232
88233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
88234   int jresult ;
88235   int result;
88236
88237   result = (int)Dali::Toolkit::Popup::Property::TITLE;
88238   jresult = (int)result;
88239   return jresult;
88240 }
88241
88242
88243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
88244   int jresult ;
88245   int result;
88246
88247   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
88248   jresult = (int)result;
88249   return jresult;
88250 }
88251
88252
88253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
88254   int jresult ;
88255   int result;
88256
88257   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
88258   jresult = (int)result;
88259   return jresult;
88260 }
88261
88262
88263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
88264   int jresult ;
88265   int result;
88266
88267   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
88268   jresult = (int)result;
88269   return jresult;
88270 }
88271
88272
88273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
88274   int jresult ;
88275   int result;
88276
88277   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
88278   jresult = (int)result;
88279   return jresult;
88280 }
88281
88282
88283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
88284   int jresult ;
88285   int result;
88286
88287   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
88288   jresult = (int)result;
88289   return jresult;
88290 }
88291
88292
88293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
88294   int jresult ;
88295   int result;
88296
88297   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
88298   jresult = (int)result;
88299   return jresult;
88300 }
88301
88302
88303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
88304   int jresult ;
88305   int result;
88306
88307   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
88308   jresult = (int)result;
88309   return jresult;
88310 }
88311
88312
88313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
88314   int jresult ;
88315   int result;
88316
88317   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
88318   jresult = (int)result;
88319   return jresult;
88320 }
88321
88322
88323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
88324   int jresult ;
88325   int result;
88326
88327   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
88328   jresult = (int)result;
88329   return jresult;
88330 }
88331
88332
88333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
88334   int jresult ;
88335   int result;
88336
88337   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
88338   jresult = (int)result;
88339   return jresult;
88340 }
88341
88342
88343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
88344   int jresult ;
88345   int result;
88346
88347   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
88348   jresult = (int)result;
88349   return jresult;
88350 }
88351
88352
88353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
88354   int jresult ;
88355   int result;
88356
88357   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
88358   jresult = (int)result;
88359   return jresult;
88360 }
88361
88362
88363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
88364   int jresult ;
88365   int result;
88366
88367   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
88368   jresult = (int)result;
88369   return jresult;
88370 }
88371
88372
88373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
88374   int jresult ;
88375   int result;
88376
88377   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
88378   jresult = (int)result;
88379   return jresult;
88380 }
88381
88382
88383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
88384   int jresult ;
88385   int result;
88386
88387   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
88388   jresult = (int)result;
88389   return jresult;
88390 }
88391
88392
88393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
88394   int jresult ;
88395   int result;
88396
88397   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
88398   jresult = (int)result;
88399   return jresult;
88400 }
88401
88402
88403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
88404   int jresult ;
88405   int result;
88406
88407   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
88408   jresult = (int)result;
88409   return jresult;
88410 }
88411
88412
88413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
88414   int jresult ;
88415   int result;
88416
88417   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
88418   jresult = (int)result;
88419   return jresult;
88420 }
88421
88422
88423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
88424   int jresult ;
88425   int result;
88426
88427   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
88428   jresult = (int)result;
88429   return jresult;
88430 }
88431
88432
88433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
88434   int jresult ;
88435   int result;
88436
88437   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
88438   jresult = (int)result;
88439   return jresult;
88440 }
88441
88442
88443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
88444   void * jresult ;
88445   Dali::Toolkit::Popup::Property *result = 0 ;
88446
88447   {
88448     try {
88449       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
88450     } catch (std::out_of_range& e) {
88451       {
88452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88453       };
88454     } catch (std::exception& e) {
88455       {
88456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88457       };
88458     } catch (Dali::DaliException e) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88461       };
88462     } catch (...) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88465       };
88466     }
88467   }
88468
88469   jresult = (void *)result;
88470   return jresult;
88471 }
88472
88473
88474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
88475   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
88476
88477   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
88478   {
88479     try {
88480       delete arg1;
88481     } catch (std::out_of_range& e) {
88482       {
88483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (std::exception& e) {
88486       {
88487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88488       };
88489     } catch (Dali::DaliException e) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88492       };
88493     } catch (...) {
88494       {
88495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88496       };
88497     }
88498   }
88499
88500 }
88501
88502
88503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
88504   void * jresult ;
88505   Dali::Toolkit::Popup *result = 0 ;
88506
88507   {
88508     try {
88509       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
88510     } catch (std::out_of_range& e) {
88511       {
88512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (std::exception& e) {
88515       {
88516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88517       };
88518     } catch (Dali::DaliException e) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88521       };
88522     } catch (...) {
88523       {
88524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88525       };
88526     }
88527   }
88528
88529   jresult = (void *)result;
88530   return jresult;
88531 }
88532
88533
88534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
88535   void * jresult ;
88536   Dali::Toolkit::Popup result;
88537
88538   {
88539     try {
88540       result = Dali::Toolkit::Popup::New();
88541     } catch (std::out_of_range& e) {
88542       {
88543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88544       };
88545     } catch (std::exception& e) {
88546       {
88547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88548       };
88549     } catch (Dali::DaliException e) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88552       };
88553     } catch (...) {
88554       {
88555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88556       };
88557     }
88558   }
88559
88560   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88561   return jresult;
88562 }
88563
88564
88565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
88566   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88567
88568   arg1 = (Dali::Toolkit::Popup *)jarg1;
88569   {
88570     try {
88571       delete arg1;
88572     } catch (std::out_of_range& e) {
88573       {
88574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88575       };
88576     } catch (std::exception& e) {
88577       {
88578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88579       };
88580     } catch (Dali::DaliException e) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88583       };
88584     } catch (...) {
88585       {
88586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88587       };
88588     }
88589   }
88590
88591 }
88592
88593
88594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
88595   void * jresult ;
88596   Dali::Toolkit::Popup *arg1 = 0 ;
88597   Dali::Toolkit::Popup *result = 0 ;
88598
88599   arg1 = (Dali::Toolkit::Popup *)jarg1;
88600   if (!arg1) {
88601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88602     return 0;
88603   }
88604   {
88605     try {
88606       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
88607     } catch (std::out_of_range& e) {
88608       {
88609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88610       };
88611     } catch (std::exception& e) {
88612       {
88613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88614       };
88615     } catch (Dali::DaliException e) {
88616       {
88617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88618       };
88619     } catch (...) {
88620       {
88621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88622       };
88623     }
88624   }
88625
88626   jresult = (void *)result;
88627   return jresult;
88628 }
88629
88630
88631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
88632   void * jresult ;
88633   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88634   Dali::Toolkit::Popup *arg2 = 0 ;
88635   Dali::Toolkit::Popup *result = 0 ;
88636
88637   arg1 = (Dali::Toolkit::Popup *)jarg1;
88638   arg2 = (Dali::Toolkit::Popup *)jarg2;
88639   if (!arg2) {
88640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
88641     return 0;
88642   }
88643   {
88644     try {
88645       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
88646     } catch (std::out_of_range& e) {
88647       {
88648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88649       };
88650     } catch (std::exception& e) {
88651       {
88652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88653       };
88654     } catch (Dali::DaliException e) {
88655       {
88656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88657       };
88658     } catch (...) {
88659       {
88660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88661       };
88662     }
88663   }
88664
88665   jresult = (void *)result;
88666   return jresult;
88667 }
88668
88669
88670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
88671   void * jresult ;
88672   Dali::BaseHandle arg1 ;
88673   Dali::BaseHandle *argp1 ;
88674   Dali::Toolkit::Popup result;
88675
88676   argp1 = (Dali::BaseHandle *)jarg1;
88677   if (!argp1) {
88678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88679     return 0;
88680   }
88681   arg1 = *argp1;
88682   {
88683     try {
88684       result = Dali::Toolkit::Popup::DownCast(arg1);
88685     } catch (std::out_of_range& e) {
88686       {
88687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88688       };
88689     } catch (std::exception& e) {
88690       {
88691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88692       };
88693     } catch (Dali::DaliException e) {
88694       {
88695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88696       };
88697     } catch (...) {
88698       {
88699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88700       };
88701     }
88702   }
88703
88704   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
88705   return jresult;
88706 }
88707
88708
88709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
88710   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88711   Dali::Actor arg2 ;
88712   Dali::Actor *argp2 ;
88713
88714   arg1 = (Dali::Toolkit::Popup *)jarg1;
88715   argp2 = (Dali::Actor *)jarg2;
88716   if (!argp2) {
88717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88718     return ;
88719   }
88720   arg2 = *argp2;
88721   {
88722     try {
88723       (arg1)->SetTitle(arg2);
88724     } catch (std::out_of_range& e) {
88725       {
88726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88727       };
88728     } catch (std::exception& e) {
88729       {
88730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88731       };
88732     } catch (Dali::DaliException e) {
88733       {
88734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88735       };
88736     } catch (...) {
88737       {
88738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88739       };
88740     }
88741   }
88742
88743 }
88744
88745
88746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
88747   void * jresult ;
88748   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88749   Dali::Actor result;
88750
88751   arg1 = (Dali::Toolkit::Popup *)jarg1;
88752   {
88753     try {
88754       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
88755     } catch (std::out_of_range& e) {
88756       {
88757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88758       };
88759     } catch (std::exception& e) {
88760       {
88761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88762       };
88763     } catch (Dali::DaliException e) {
88764       {
88765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88766       };
88767     } catch (...) {
88768       {
88769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88770       };
88771     }
88772   }
88773
88774   jresult = new Dali::Actor((const Dali::Actor &)result);
88775   return jresult;
88776 }
88777
88778
88779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
88780   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88781   Dali::Actor arg2 ;
88782   Dali::Actor *argp2 ;
88783
88784   arg1 = (Dali::Toolkit::Popup *)jarg1;
88785   argp2 = (Dali::Actor *)jarg2;
88786   if (!argp2) {
88787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88788     return ;
88789   }
88790   arg2 = *argp2;
88791   {
88792     try {
88793       (arg1)->SetContent(arg2);
88794     } catch (std::out_of_range& e) {
88795       {
88796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88797       };
88798     } catch (std::exception& e) {
88799       {
88800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88801       };
88802     } catch (Dali::DaliException e) {
88803       {
88804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88805       };
88806     } catch (...) {
88807       {
88808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88809       };
88810     }
88811   }
88812
88813 }
88814
88815
88816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88817   void * jresult ;
88818   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88819   Dali::Actor result;
88820
88821   arg1 = (Dali::Toolkit::Popup *)jarg1;
88822   {
88823     try {
88824       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88825     } catch (std::out_of_range& e) {
88826       {
88827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88828       };
88829     } catch (std::exception& e) {
88830       {
88831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88832       };
88833     } catch (Dali::DaliException e) {
88834       {
88835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88836       };
88837     } catch (...) {
88838       {
88839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88840       };
88841     }
88842   }
88843
88844   jresult = new Dali::Actor((const Dali::Actor &)result);
88845   return jresult;
88846 }
88847
88848
88849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88850   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88851   Dali::Actor arg2 ;
88852   Dali::Actor *argp2 ;
88853
88854   arg1 = (Dali::Toolkit::Popup *)jarg1;
88855   argp2 = (Dali::Actor *)jarg2;
88856   if (!argp2) {
88857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88858     return ;
88859   }
88860   arg2 = *argp2;
88861   {
88862     try {
88863       (arg1)->SetFooter(arg2);
88864     } catch (std::out_of_range& e) {
88865       {
88866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88867       };
88868     } catch (std::exception& e) {
88869       {
88870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88871       };
88872     } catch (Dali::DaliException e) {
88873       {
88874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88875       };
88876     } catch (...) {
88877       {
88878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88879       };
88880     }
88881   }
88882
88883 }
88884
88885
88886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88887   void * jresult ;
88888   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88889   Dali::Actor result;
88890
88891   arg1 = (Dali::Toolkit::Popup *)jarg1;
88892   {
88893     try {
88894       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88895     } catch (std::out_of_range& e) {
88896       {
88897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88898       };
88899     } catch (std::exception& e) {
88900       {
88901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88902       };
88903     } catch (Dali::DaliException e) {
88904       {
88905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88906       };
88907     } catch (...) {
88908       {
88909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88910       };
88911     }
88912   }
88913
88914   jresult = new Dali::Actor((const Dali::Actor &)result);
88915   return jresult;
88916 }
88917
88918
88919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88920   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88921   Dali::Toolkit::Popup::DisplayState arg2 ;
88922
88923   arg1 = (Dali::Toolkit::Popup *)jarg1;
88924   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88925   {
88926     try {
88927       (arg1)->SetDisplayState(arg2);
88928     } catch (std::out_of_range& e) {
88929       {
88930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88931       };
88932     } catch (std::exception& e) {
88933       {
88934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88935       };
88936     } catch (Dali::DaliException e) {
88937       {
88938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88939       };
88940     } catch (...) {
88941       {
88942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88943       };
88944     }
88945   }
88946
88947 }
88948
88949
88950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88951   int jresult ;
88952   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88953   Dali::Toolkit::Popup::DisplayState result;
88954
88955   arg1 = (Dali::Toolkit::Popup *)jarg1;
88956   {
88957     try {
88958       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88959     } catch (std::out_of_range& e) {
88960       {
88961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88962       };
88963     } catch (std::exception& e) {
88964       {
88965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88966       };
88967     } catch (Dali::DaliException e) {
88968       {
88969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88970       };
88971     } catch (...) {
88972       {
88973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88974       };
88975     }
88976   }
88977
88978   jresult = (int)result;
88979   return jresult;
88980 }
88981
88982
88983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88984   void * jresult ;
88985   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88986   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88987
88988   arg1 = (Dali::Toolkit::Popup *)jarg1;
88989   {
88990     try {
88991       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88992     } catch (std::out_of_range& e) {
88993       {
88994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88995       };
88996     } catch (std::exception& e) {
88997       {
88998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88999       };
89000     } catch (Dali::DaliException e) {
89001       {
89002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89003       };
89004     } catch (...) {
89005       {
89006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89007       };
89008     }
89009   }
89010
89011   jresult = (void *)result;
89012   return jresult;
89013 }
89014
89015
89016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
89017   void * jresult ;
89018   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89019   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89020
89021   arg1 = (Dali::Toolkit::Popup *)jarg1;
89022   {
89023     try {
89024       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
89025     } catch (std::out_of_range& e) {
89026       {
89027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89028       };
89029     } catch (std::exception& e) {
89030       {
89031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89032       };
89033     } catch (Dali::DaliException e) {
89034       {
89035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89036       };
89037     } catch (...) {
89038       {
89039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89040       };
89041     }
89042   }
89043
89044   jresult = (void *)result;
89045   return jresult;
89046 }
89047
89048
89049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
89050   void * jresult ;
89051   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89052   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89053
89054   arg1 = (Dali::Toolkit::Popup *)jarg1;
89055   {
89056     try {
89057       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
89058     } catch (std::out_of_range& e) {
89059       {
89060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89061       };
89062     } catch (std::exception& e) {
89063       {
89064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89065       };
89066     } catch (Dali::DaliException e) {
89067       {
89068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89069       };
89070     } catch (...) {
89071       {
89072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89073       };
89074     }
89075   }
89076
89077   jresult = (void *)result;
89078   return jresult;
89079 }
89080
89081
89082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
89083   void * jresult ;
89084   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89085   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89086
89087   arg1 = (Dali::Toolkit::Popup *)jarg1;
89088   {
89089     try {
89090       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
89091     } catch (std::out_of_range& e) {
89092       {
89093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89094       };
89095     } catch (std::exception& e) {
89096       {
89097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89098       };
89099     } catch (Dali::DaliException e) {
89100       {
89101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89102       };
89103     } catch (...) {
89104       {
89105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89106       };
89107     }
89108   }
89109
89110   jresult = (void *)result;
89111   return jresult;
89112 }
89113
89114
89115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
89116   void * jresult ;
89117   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
89118   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
89119
89120   arg1 = (Dali::Toolkit::Popup *)jarg1;
89121   {
89122     try {
89123       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
89124     } catch (std::out_of_range& e) {
89125       {
89126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89127       };
89128     } catch (std::exception& e) {
89129       {
89130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89131       };
89132     } catch (Dali::DaliException e) {
89133       {
89134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89135       };
89136     } catch (...) {
89137       {
89138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89139       };
89140     }
89141   }
89142
89143   jresult = (void *)result;
89144   return jresult;
89145 }
89146
89147
89148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
89149   int jresult ;
89150   int result;
89151
89152   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
89153   jresult = (int)result;
89154   return jresult;
89155 }
89156
89157
89158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
89159   int jresult ;
89160   int result;
89161
89162   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
89163   jresult = (int)result;
89164   return jresult;
89165 }
89166
89167
89168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
89169   int jresult ;
89170   int result;
89171
89172   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
89173   jresult = (int)result;
89174   return jresult;
89175 }
89176
89177
89178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
89179   int jresult ;
89180   int result;
89181
89182   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
89183   jresult = (int)result;
89184   return jresult;
89185 }
89186
89187
89188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
89189   int jresult ;
89190   int result;
89191
89192   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
89193   jresult = (int)result;
89194   return jresult;
89195 }
89196
89197
89198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
89199   int jresult ;
89200   int result;
89201
89202   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
89203   jresult = (int)result;
89204   return jresult;
89205 }
89206
89207
89208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
89209   int jresult ;
89210   int result;
89211
89212   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
89213   jresult = (int)result;
89214   return jresult;
89215 }
89216
89217
89218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
89219   int jresult ;
89220   int result;
89221
89222   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
89223   jresult = (int)result;
89224   return jresult;
89225 }
89226
89227
89228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
89229   int jresult ;
89230   int result;
89231
89232   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
89233   jresult = (int)result;
89234   return jresult;
89235 }
89236
89237
89238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
89239   void * jresult ;
89240   Dali::Toolkit::ProgressBar::Property *result = 0 ;
89241
89242   {
89243     try {
89244       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
89245     } catch (std::out_of_range& e) {
89246       {
89247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89248       };
89249     } catch (std::exception& e) {
89250       {
89251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89252       };
89253     } catch (Dali::DaliException e) {
89254       {
89255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89256       };
89257     } catch (...) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89260       };
89261     }
89262   }
89263
89264   jresult = (void *)result;
89265   return jresult;
89266 }
89267
89268
89269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
89270   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
89271
89272   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
89273   {
89274     try {
89275       delete arg1;
89276     } catch (std::out_of_range& e) {
89277       {
89278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89279       };
89280     } catch (std::exception& e) {
89281       {
89282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89283       };
89284     } catch (Dali::DaliException e) {
89285       {
89286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89287       };
89288     } catch (...) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89291       };
89292     }
89293   }
89294
89295 }
89296
89297
89298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
89299   void * jresult ;
89300   Dali::Toolkit::ProgressBar result;
89301
89302   {
89303     try {
89304       result = Dali::Toolkit::ProgressBar::New();
89305     } catch (std::out_of_range& e) {
89306       {
89307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89308       };
89309     } catch (std::exception& e) {
89310       {
89311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89312       };
89313     } catch (Dali::DaliException e) {
89314       {
89315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89316       };
89317     } catch (...) {
89318       {
89319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89320       };
89321     }
89322   }
89323
89324   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89325   return jresult;
89326 }
89327
89328
89329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
89330   void * jresult ;
89331   Dali::Toolkit::ProgressBar *result = 0 ;
89332
89333   {
89334     try {
89335       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
89336     } catch (std::out_of_range& e) {
89337       {
89338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89339       };
89340     } catch (std::exception& e) {
89341       {
89342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89343       };
89344     } catch (Dali::DaliException e) {
89345       {
89346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89347       };
89348     } catch (...) {
89349       {
89350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89351       };
89352     }
89353   }
89354
89355   jresult = (void *)result;
89356   return jresult;
89357 }
89358
89359
89360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
89361   void * jresult ;
89362   Dali::Toolkit::ProgressBar *arg1 = 0 ;
89363   Dali::Toolkit::ProgressBar *result = 0 ;
89364
89365   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89366   if (!arg1) {
89367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89368     return 0;
89369   }
89370   {
89371     try {
89372       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
89373     } catch (std::out_of_range& e) {
89374       {
89375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89376       };
89377     } catch (std::exception& e) {
89378       {
89379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89380       };
89381     } catch (Dali::DaliException e) {
89382       {
89383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89384       };
89385     } catch (...) {
89386       {
89387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89388       };
89389     }
89390   }
89391
89392   jresult = (void *)result;
89393   return jresult;
89394 }
89395
89396
89397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
89398   void * jresult ;
89399   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89400   Dali::Toolkit::ProgressBar *arg2 = 0 ;
89401   Dali::Toolkit::ProgressBar *result = 0 ;
89402
89403   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89404   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
89405   if (!arg2) {
89406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
89407     return 0;
89408   }
89409   {
89410     try {
89411       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
89412     } catch (std::out_of_range& e) {
89413       {
89414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89415       };
89416     } catch (std::exception& e) {
89417       {
89418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89419       };
89420     } catch (Dali::DaliException e) {
89421       {
89422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89423       };
89424     } catch (...) {
89425       {
89426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89427       };
89428     }
89429   }
89430
89431   jresult = (void *)result;
89432   return jresult;
89433 }
89434
89435
89436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
89437   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89438
89439   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89440   {
89441     try {
89442       delete arg1;
89443     } catch (std::out_of_range& e) {
89444       {
89445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89446       };
89447     } catch (std::exception& e) {
89448       {
89449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89450       };
89451     } catch (Dali::DaliException e) {
89452       {
89453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89454       };
89455     } catch (...) {
89456       {
89457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89458       };
89459     }
89460   }
89461
89462 }
89463
89464
89465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
89466   void * jresult ;
89467   Dali::BaseHandle arg1 ;
89468   Dali::BaseHandle *argp1 ;
89469   Dali::Toolkit::ProgressBar result;
89470
89471   argp1 = (Dali::BaseHandle *)jarg1;
89472   if (!argp1) {
89473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89474     return 0;
89475   }
89476   arg1 = *argp1;
89477   {
89478     try {
89479       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
89480     } catch (std::out_of_range& e) {
89481       {
89482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89483       };
89484     } catch (std::exception& e) {
89485       {
89486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89487       };
89488     } catch (Dali::DaliException e) {
89489       {
89490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89491       };
89492     } catch (...) {
89493       {
89494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89495       };
89496     }
89497   }
89498
89499   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
89500   return jresult;
89501 }
89502
89503
89504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
89505   void * jresult ;
89506   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
89507   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
89508
89509   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
89510   {
89511     try {
89512       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
89513     } catch (std::out_of_range& e) {
89514       {
89515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89516       };
89517     } catch (std::exception& e) {
89518       {
89519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89520       };
89521     } catch (Dali::DaliException e) {
89522       {
89523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89524       };
89525     } catch (...) {
89526       {
89527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89528       };
89529     }
89530   }
89531
89532   jresult = (void *)result;
89533   return jresult;
89534 }
89535
89536
89537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
89538   void * jresult ;
89539   Dali::Toolkit::GaussianBlurView *result = 0 ;
89540
89541   {
89542     try {
89543       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
89544     } catch (std::out_of_range& e) {
89545       {
89546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89547       };
89548     } catch (std::exception& e) {
89549       {
89550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89551       };
89552     } catch (Dali::DaliException e) {
89553       {
89554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89555       };
89556     } catch (...) {
89557       {
89558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89559       };
89560     }
89561   }
89562
89563   jresult = (void *)result;
89564   return jresult;
89565 }
89566
89567
89568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
89569   void * jresult ;
89570   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
89571   Dali::Toolkit::GaussianBlurView *result = 0 ;
89572
89573   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89574   if (!arg1) {
89575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89576     return 0;
89577   }
89578   {
89579     try {
89580       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
89581     } catch (std::out_of_range& e) {
89582       {
89583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89584       };
89585     } catch (std::exception& e) {
89586       {
89587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89588       };
89589     } catch (Dali::DaliException e) {
89590       {
89591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89592       };
89593     } catch (...) {
89594       {
89595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89596       };
89597     }
89598   }
89599
89600   jresult = (void *)result;
89601   return jresult;
89602 }
89603
89604
89605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
89606   void * jresult ;
89607   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89608   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
89609   Dali::Toolkit::GaussianBlurView *result = 0 ;
89610
89611   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89612   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
89613   if (!arg2) {
89614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
89615     return 0;
89616   }
89617   {
89618     try {
89619       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
89620     } catch (std::out_of_range& e) {
89621       {
89622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89623       };
89624     } catch (std::exception& e) {
89625       {
89626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89627       };
89628     } catch (Dali::DaliException e) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89631       };
89632     } catch (...) {
89633       {
89634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89635       };
89636     }
89637   }
89638
89639   jresult = (void *)result;
89640   return jresult;
89641 }
89642
89643
89644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
89645   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89646
89647   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89648   {
89649     try {
89650       delete arg1;
89651     } catch (std::out_of_range& e) {
89652       {
89653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89654       };
89655     } catch (std::exception& e) {
89656       {
89657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89658       };
89659     } catch (Dali::DaliException e) {
89660       {
89661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89662       };
89663     } catch (...) {
89664       {
89665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89666       };
89667     }
89668   }
89669
89670 }
89671
89672
89673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
89674   void * jresult ;
89675   Dali::BaseHandle arg1 ;
89676   Dali::BaseHandle *argp1 ;
89677   Dali::Toolkit::GaussianBlurView result;
89678
89679   argp1 = (Dali::BaseHandle *)jarg1;
89680   if (!argp1) {
89681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89682     return 0;
89683   }
89684   arg1 = *argp1;
89685   {
89686     try {
89687       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
89688     } catch (std::out_of_range& e) {
89689       {
89690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89691       };
89692     } catch (std::exception& e) {
89693       {
89694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89695       };
89696     } catch (Dali::DaliException e) {
89697       {
89698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89699       };
89700     } catch (...) {
89701       {
89702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89703       };
89704     }
89705   }
89706
89707   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89708   return jresult;
89709 }
89710
89711
89712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
89713   void * jresult ;
89714   Dali::Toolkit::GaussianBlurView result;
89715
89716   {
89717     try {
89718       result = Dali::Toolkit::GaussianBlurView::New();
89719     } catch (std::out_of_range& e) {
89720       {
89721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89722       };
89723     } catch (std::exception& e) {
89724       {
89725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89726       };
89727     } catch (Dali::DaliException e) {
89728       {
89729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89730       };
89731     } catch (...) {
89732       {
89733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89734       };
89735     }
89736   }
89737
89738   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89739   return jresult;
89740 }
89741
89742
89743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
89744   void * jresult ;
89745   unsigned int arg1 ;
89746   float arg2 ;
89747   Dali::Pixel::Format arg3 ;
89748   float arg4 ;
89749   float arg5 ;
89750   bool arg6 ;
89751   Dali::Toolkit::GaussianBlurView result;
89752
89753   arg1 = (unsigned int)jarg1;
89754   arg2 = (float)jarg2;
89755   arg3 = (Dali::Pixel::Format)jarg3;
89756   arg4 = (float)jarg4;
89757   arg5 = (float)jarg5;
89758   arg6 = jarg6 ? true : false;
89759   {
89760     try {
89761       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
89762     } catch (std::out_of_range& e) {
89763       {
89764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89765       };
89766     } catch (std::exception& e) {
89767       {
89768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89769       };
89770     } catch (Dali::DaliException e) {
89771       {
89772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89773       };
89774     } catch (...) {
89775       {
89776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89777       };
89778     }
89779   }
89780
89781   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89782   return jresult;
89783 }
89784
89785
89786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
89787   void * jresult ;
89788   unsigned int arg1 ;
89789   float arg2 ;
89790   Dali::Pixel::Format arg3 ;
89791   float arg4 ;
89792   float arg5 ;
89793   Dali::Toolkit::GaussianBlurView result;
89794
89795   arg1 = (unsigned int)jarg1;
89796   arg2 = (float)jarg2;
89797   arg3 = (Dali::Pixel::Format)jarg3;
89798   arg4 = (float)jarg4;
89799   arg5 = (float)jarg5;
89800   {
89801     try {
89802       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89803     } catch (std::out_of_range& e) {
89804       {
89805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89806       };
89807     } catch (std::exception& e) {
89808       {
89809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89810       };
89811     } catch (Dali::DaliException e) {
89812       {
89813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89814       };
89815     } catch (...) {
89816       {
89817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89818       };
89819     }
89820   }
89821
89822   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89823   return jresult;
89824 }
89825
89826
89827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89828   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89829   Dali::Actor arg2 ;
89830   Dali::Actor *argp2 ;
89831
89832   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89833   argp2 = (Dali::Actor *)jarg2;
89834   if (!argp2) {
89835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89836     return ;
89837   }
89838   arg2 = *argp2;
89839   {
89840     try {
89841       (arg1)->Add(arg2);
89842     } catch (std::out_of_range& e) {
89843       {
89844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89845       };
89846     } catch (std::exception& e) {
89847       {
89848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89849       };
89850     } catch (Dali::DaliException e) {
89851       {
89852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89853       };
89854     } catch (...) {
89855       {
89856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89857       };
89858     }
89859   }
89860
89861 }
89862
89863
89864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89865   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89866   Dali::Actor arg2 ;
89867   Dali::Actor *argp2 ;
89868
89869   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89870   argp2 = (Dali::Actor *)jarg2;
89871   if (!argp2) {
89872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89873     return ;
89874   }
89875   arg2 = *argp2;
89876   {
89877     try {
89878       (arg1)->Remove(arg2);
89879     } catch (std::out_of_range& e) {
89880       {
89881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (std::exception& e) {
89884       {
89885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89886       };
89887     } catch (Dali::DaliException e) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89890       };
89891     } catch (...) {
89892       {
89893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89894       };
89895     }
89896   }
89897
89898 }
89899
89900
89901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89902   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89903
89904   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89905   {
89906     try {
89907       (arg1)->Activate();
89908     } catch (std::out_of_range& e) {
89909       {
89910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89911       };
89912     } catch (std::exception& e) {
89913       {
89914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89915       };
89916     } catch (Dali::DaliException e) {
89917       {
89918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89919       };
89920     } catch (...) {
89921       {
89922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89923       };
89924     }
89925   }
89926
89927 }
89928
89929
89930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89931   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89932
89933   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89934   {
89935     try {
89936       (arg1)->ActivateOnce();
89937     } catch (std::out_of_range& e) {
89938       {
89939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89940       };
89941     } catch (std::exception& e) {
89942       {
89943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89944       };
89945     } catch (Dali::DaliException e) {
89946       {
89947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89948       };
89949     } catch (...) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89952       };
89953     }
89954   }
89955
89956 }
89957
89958
89959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89960   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89961
89962   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89963   {
89964     try {
89965       (arg1)->Deactivate();
89966     } catch (std::out_of_range& e) {
89967       {
89968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89969       };
89970     } catch (std::exception& e) {
89971       {
89972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89973       };
89974     } catch (Dali::DaliException e) {
89975       {
89976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89977       };
89978     } catch (...) {
89979       {
89980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89981       };
89982     }
89983   }
89984
89985 }
89986
89987
89988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89989   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89990   Dali::Image arg2 ;
89991   Dali::FrameBufferImage arg3 ;
89992   Dali::Image *argp2 ;
89993   Dali::FrameBufferImage *argp3 ;
89994
89995   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89996   argp2 = (Dali::Image *)jarg2;
89997   if (!argp2) {
89998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89999     return ;
90000   }
90001   arg2 = *argp2;
90002   argp3 = (Dali::FrameBufferImage *)jarg3;
90003   if (!argp3) {
90004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
90005     return ;
90006   }
90007   arg3 = *argp3;
90008   {
90009     try {
90010       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
90011     } catch (std::out_of_range& e) {
90012       {
90013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90014       };
90015     } catch (std::exception& e) {
90016       {
90017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90018       };
90019     } catch (Dali::DaliException e) {
90020       {
90021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90022       };
90023     } catch (...) {
90024       {
90025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90026       };
90027     }
90028   }
90029
90030 }
90031
90032
90033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
90034   int jresult ;
90035   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90036   Dali::Property::Index result;
90037
90038   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90039   {
90040     try {
90041       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
90042     } catch (std::out_of_range& e) {
90043       {
90044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90045       };
90046     } catch (std::exception& e) {
90047       {
90048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90049       };
90050     } catch (Dali::DaliException e) {
90051       {
90052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90053       };
90054     } catch (...) {
90055       {
90056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90057       };
90058     }
90059   }
90060
90061   jresult = result;
90062   return jresult;
90063 }
90064
90065
90066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
90067   void * jresult ;
90068   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90069   Dali::FrameBufferImage result;
90070
90071   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90072   {
90073     try {
90074       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
90075     } catch (std::out_of_range& e) {
90076       {
90077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90078       };
90079     } catch (std::exception& e) {
90080       {
90081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90082       };
90083     } catch (Dali::DaliException e) {
90084       {
90085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90086       };
90087     } catch (...) {
90088       {
90089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90090       };
90091     }
90092   }
90093
90094   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
90095   return jresult;
90096 }
90097
90098
90099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
90100   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90101   Dali::Vector4 *arg2 = 0 ;
90102
90103   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90104   arg2 = (Dali::Vector4 *)jarg2;
90105   if (!arg2) {
90106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
90107     return ;
90108   }
90109   {
90110     try {
90111       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
90112     } catch (std::out_of_range& e) {
90113       {
90114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90115       };
90116     } catch (std::exception& e) {
90117       {
90118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90119       };
90120     } catch (Dali::DaliException e) {
90121       {
90122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90123       };
90124     } catch (...) {
90125       {
90126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90127       };
90128     }
90129   }
90130
90131 }
90132
90133
90134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
90135   void * jresult ;
90136   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90137   Dali::Vector4 result;
90138
90139   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90140   {
90141     try {
90142       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
90143     } catch (std::out_of_range& e) {
90144       {
90145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90146       };
90147     } catch (std::exception& e) {
90148       {
90149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (Dali::DaliException e) {
90152       {
90153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90154       };
90155     } catch (...) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90158       };
90159     }
90160   }
90161
90162   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
90163   return jresult;
90164 }
90165
90166
90167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
90168   void * jresult ;
90169   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
90170   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
90171
90172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
90173   {
90174     try {
90175       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
90176     } catch (std::out_of_range& e) {
90177       {
90178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (std::exception& e) {
90181       {
90182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90183       };
90184     } catch (Dali::DaliException e) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90187       };
90188     } catch (...) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90191       };
90192     }
90193   }
90194
90195   jresult = (void *)result;
90196   return jresult;
90197 }
90198
90199
90200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
90201   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90202
90203   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90204   {
90205     try {
90206       delete arg1;
90207     } catch (std::out_of_range& e) {
90208       {
90209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90210       };
90211     } catch (std::exception& e) {
90212       {
90213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90214       };
90215     } catch (Dali::DaliException e) {
90216       {
90217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90218       };
90219     } catch (...) {
90220       {
90221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90222       };
90223     }
90224   }
90225
90226 }
90227
90228
90229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
90230   unsigned int jresult ;
90231   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90232   unsigned int result;
90233
90234   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90235   {
90236     try {
90237       result = (unsigned int)(arg1)->GetNumberOfPages();
90238     } catch (std::out_of_range& e) {
90239       {
90240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90241       };
90242     } catch (std::exception& e) {
90243       {
90244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90245       };
90246     } catch (Dali::DaliException e) {
90247       {
90248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90249       };
90250     } catch (...) {
90251       {
90252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90253       };
90254     }
90255   }
90256
90257   jresult = result;
90258   return jresult;
90259 }
90260
90261
90262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
90263   void * jresult ;
90264   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
90265   unsigned int arg2 ;
90266   Dali::Texture result;
90267
90268   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90269   arg2 = (unsigned int)jarg2;
90270   {
90271     try {
90272       result = (arg1)->NewPage(arg2);
90273     } catch (std::out_of_range& e) {
90274       {
90275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (std::exception& e) {
90278       {
90279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90280       };
90281     } catch (Dali::DaliException e) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90284       };
90285     } catch (...) {
90286       {
90287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90288       };
90289     }
90290   }
90291
90292   jresult = new Dali::Texture((const Dali::Texture &)result);
90293   return jresult;
90294 }
90295
90296
90297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
90298   int jresult ;
90299   int result;
90300
90301   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
90302   jresult = (int)result;
90303   return jresult;
90304 }
90305
90306
90307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
90308   int jresult ;
90309   int result;
90310
90311   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
90312   jresult = (int)result;
90313   return jresult;
90314 }
90315
90316
90317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
90318   int jresult ;
90319   int result;
90320
90321   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
90322   jresult = (int)result;
90323   return jresult;
90324 }
90325
90326
90327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
90328   void * jresult ;
90329   Dali::Toolkit::PageTurnView::Property *result = 0 ;
90330
90331   {
90332     try {
90333       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
90334     } catch (std::out_of_range& e) {
90335       {
90336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90337       };
90338     } catch (std::exception& e) {
90339       {
90340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90341       };
90342     } catch (Dali::DaliException e) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90345       };
90346     } catch (...) {
90347       {
90348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90349       };
90350     }
90351   }
90352
90353   jresult = (void *)result;
90354   return jresult;
90355 }
90356
90357
90358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
90359   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
90360
90361   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
90362   {
90363     try {
90364       delete arg1;
90365     } catch (std::out_of_range& e) {
90366       {
90367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90368       };
90369     } catch (std::exception& e) {
90370       {
90371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90372       };
90373     } catch (Dali::DaliException e) {
90374       {
90375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90376       };
90377     } catch (...) {
90378       {
90379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90380       };
90381     }
90382   }
90383
90384 }
90385
90386
90387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
90388   void * jresult ;
90389   Dali::Toolkit::PageTurnView *result = 0 ;
90390
90391   {
90392     try {
90393       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
90394     } catch (std::out_of_range& e) {
90395       {
90396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (std::exception& e) {
90399       {
90400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90401       };
90402     } catch (Dali::DaliException e) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90405       };
90406     } catch (...) {
90407       {
90408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90409       };
90410     }
90411   }
90412
90413   jresult = (void *)result;
90414   return jresult;
90415 }
90416
90417
90418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
90419   void * jresult ;
90420   Dali::Toolkit::PageTurnView *arg1 = 0 ;
90421   Dali::Toolkit::PageTurnView *result = 0 ;
90422
90423   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90424   if (!arg1) {
90425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90426     return 0;
90427   }
90428   {
90429     try {
90430       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
90431     } catch (std::out_of_range& e) {
90432       {
90433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90434       };
90435     } catch (std::exception& e) {
90436       {
90437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90438       };
90439     } catch (Dali::DaliException e) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90442       };
90443     } catch (...) {
90444       {
90445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90446       };
90447     }
90448   }
90449
90450   jresult = (void *)result;
90451   return jresult;
90452 }
90453
90454
90455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
90456   void * jresult ;
90457   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90458   Dali::Toolkit::PageTurnView *arg2 = 0 ;
90459   Dali::Toolkit::PageTurnView *result = 0 ;
90460
90461   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90462   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
90463   if (!arg2) {
90464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
90465     return 0;
90466   }
90467   {
90468     try {
90469       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
90470     } catch (std::out_of_range& e) {
90471       {
90472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90473       };
90474     } catch (std::exception& e) {
90475       {
90476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90477       };
90478     } catch (Dali::DaliException e) {
90479       {
90480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90481       };
90482     } catch (...) {
90483       {
90484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90485       };
90486     }
90487   }
90488
90489   jresult = (void *)result;
90490   return jresult;
90491 }
90492
90493
90494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
90495   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90496
90497   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90498   {
90499     try {
90500       delete arg1;
90501     } catch (std::out_of_range& e) {
90502       {
90503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90504       };
90505     } catch (std::exception& e) {
90506       {
90507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90508       };
90509     } catch (Dali::DaliException e) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90512       };
90513     } catch (...) {
90514       {
90515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90516       };
90517     }
90518   }
90519
90520 }
90521
90522
90523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
90524   void * jresult ;
90525   Dali::BaseHandle arg1 ;
90526   Dali::BaseHandle *argp1 ;
90527   Dali::Toolkit::PageTurnView result;
90528
90529   argp1 = (Dali::BaseHandle *)jarg1;
90530   if (!argp1) {
90531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90532     return 0;
90533   }
90534   arg1 = *argp1;
90535   {
90536     try {
90537       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
90538     } catch (std::out_of_range& e) {
90539       {
90540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90541       };
90542     } catch (std::exception& e) {
90543       {
90544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (Dali::DaliException e) {
90547       {
90548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90549       };
90550     } catch (...) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90553       };
90554     }
90555   }
90556
90557   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
90558   return jresult;
90559 }
90560
90561
90562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
90563   void * jresult ;
90564   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90565   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90566
90567   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90568   {
90569     try {
90570       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
90571     } catch (std::out_of_range& e) {
90572       {
90573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90574       };
90575     } catch (std::exception& e) {
90576       {
90577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90578       };
90579     } catch (Dali::DaliException e) {
90580       {
90581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90582       };
90583     } catch (...) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90586       };
90587     }
90588   }
90589
90590   jresult = (void *)result;
90591   return jresult;
90592 }
90593
90594
90595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
90596   void * jresult ;
90597   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90598   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
90599
90600   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90601   {
90602     try {
90603       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
90604     } catch (std::out_of_range& e) {
90605       {
90606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90607       };
90608     } catch (std::exception& e) {
90609       {
90610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90611       };
90612     } catch (Dali::DaliException e) {
90613       {
90614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90615       };
90616     } catch (...) {
90617       {
90618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90619       };
90620     }
90621   }
90622
90623   jresult = (void *)result;
90624   return jresult;
90625 }
90626
90627
90628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
90629   void * jresult ;
90630   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90631   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90632
90633   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90634   {
90635     try {
90636       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
90637     } catch (std::out_of_range& e) {
90638       {
90639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90640       };
90641     } catch (std::exception& e) {
90642       {
90643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90644       };
90645     } catch (Dali::DaliException e) {
90646       {
90647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90648       };
90649     } catch (...) {
90650       {
90651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90652       };
90653     }
90654   }
90655
90656   jresult = (void *)result;
90657   return jresult;
90658 }
90659
90660
90661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
90662   void * jresult ;
90663   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
90664   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
90665
90666   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
90667   {
90668     try {
90669       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
90670     } catch (std::out_of_range& e) {
90671       {
90672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90673       };
90674     } catch (std::exception& e) {
90675       {
90676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90677       };
90678     } catch (Dali::DaliException e) {
90679       {
90680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90681       };
90682     } catch (...) {
90683       {
90684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90685       };
90686     }
90687   }
90688
90689   jresult = (void *)result;
90690   return jresult;
90691 }
90692
90693
90694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
90695   void * jresult ;
90696   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90697
90698   {
90699     try {
90700       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
90701     } catch (std::out_of_range& e) {
90702       {
90703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90704       };
90705     } catch (std::exception& e) {
90706       {
90707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90708       };
90709     } catch (Dali::DaliException e) {
90710       {
90711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90712       };
90713     } catch (...) {
90714       {
90715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90716       };
90717     }
90718   }
90719
90720   jresult = (void *)result;
90721   return jresult;
90722 }
90723
90724
90725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
90726   void * jresult ;
90727   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
90728   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90729
90730   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90731   if (!arg1) {
90732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90733     return 0;
90734   }
90735   {
90736     try {
90737       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90753       };
90754     }
90755   }
90756
90757   jresult = (void *)result;
90758   return jresult;
90759 }
90760
90761
90762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
90763   void * jresult ;
90764   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90765   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
90766   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
90767
90768   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90769   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
90770   if (!arg2) {
90771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
90772     return 0;
90773   }
90774   {
90775     try {
90776       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
90777     } catch (std::out_of_range& e) {
90778       {
90779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90780       };
90781     } catch (std::exception& e) {
90782       {
90783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90784       };
90785     } catch (Dali::DaliException e) {
90786       {
90787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90788       };
90789     } catch (...) {
90790       {
90791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90792       };
90793     }
90794   }
90795
90796   jresult = (void *)result;
90797   return jresult;
90798 }
90799
90800
90801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90802   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90803
90804   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90805   {
90806     try {
90807       delete arg1;
90808     } catch (std::out_of_range& e) {
90809       {
90810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90811       };
90812     } catch (std::exception& e) {
90813       {
90814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90815       };
90816     } catch (Dali::DaliException e) {
90817       {
90818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90819       };
90820     } catch (...) {
90821       {
90822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90823       };
90824     }
90825   }
90826
90827 }
90828
90829
90830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90831   void * jresult ;
90832   Dali::Toolkit::PageFactory *arg1 = 0 ;
90833   Dali::Vector2 *arg2 = 0 ;
90834   Dali::Toolkit::PageTurnLandscapeView result;
90835
90836   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90837   if (!arg1) {
90838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90839     return 0;
90840   }
90841   arg2 = (Dali::Vector2 *)jarg2;
90842   if (!arg2) {
90843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90844     return 0;
90845   }
90846   {
90847     try {
90848       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90849     } catch (std::out_of_range& e) {
90850       {
90851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90852       };
90853     } catch (std::exception& e) {
90854       {
90855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90856       };
90857     } catch (Dali::DaliException e) {
90858       {
90859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90860       };
90861     } catch (...) {
90862       {
90863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90864       };
90865     }
90866   }
90867
90868   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90869   return jresult;
90870 }
90871
90872
90873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90874   void * jresult ;
90875   Dali::BaseHandle arg1 ;
90876   Dali::BaseHandle *argp1 ;
90877   Dali::Toolkit::PageTurnLandscapeView result;
90878
90879   argp1 = (Dali::BaseHandle *)jarg1;
90880   if (!argp1) {
90881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90882     return 0;
90883   }
90884   arg1 = *argp1;
90885   {
90886     try {
90887       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90888     } catch (std::out_of_range& e) {
90889       {
90890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90891       };
90892     } catch (std::exception& e) {
90893       {
90894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90895       };
90896     } catch (Dali::DaliException e) {
90897       {
90898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90899       };
90900     } catch (...) {
90901       {
90902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90903       };
90904     }
90905   }
90906
90907   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90908   return jresult;
90909 }
90910
90911
90912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90913   void * jresult ;
90914   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90915
90916   {
90917     try {
90918       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90919     } catch (std::out_of_range& e) {
90920       {
90921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90922       };
90923     } catch (std::exception& e) {
90924       {
90925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90926       };
90927     } catch (Dali::DaliException e) {
90928       {
90929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90930       };
90931     } catch (...) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90934       };
90935     }
90936   }
90937
90938   jresult = (void *)result;
90939   return jresult;
90940 }
90941
90942
90943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90944   void * jresult ;
90945   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90946   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90947
90948   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90949   if (!arg1) {
90950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90951     return 0;
90952   }
90953   {
90954     try {
90955       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90956     } catch (std::out_of_range& e) {
90957       {
90958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90959       };
90960     } catch (std::exception& e) {
90961       {
90962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90963       };
90964     } catch (Dali::DaliException e) {
90965       {
90966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90967       };
90968     } catch (...) {
90969       {
90970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90971       };
90972     }
90973   }
90974
90975   jresult = (void *)result;
90976   return jresult;
90977 }
90978
90979
90980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90981   void * jresult ;
90982   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90983   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90984   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90985
90986   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90987   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90988   if (!arg2) {
90989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90990     return 0;
90991   }
90992   {
90993     try {
90994       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90995     } catch (std::out_of_range& e) {
90996       {
90997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90998       };
90999     } catch (std::exception& e) {
91000       {
91001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91002       };
91003     } catch (Dali::DaliException e) {
91004       {
91005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91006       };
91007     } catch (...) {
91008       {
91009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91010       };
91011     }
91012   }
91013
91014   jresult = (void *)result;
91015   return jresult;
91016 }
91017
91018
91019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
91020   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
91021
91022   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
91023   {
91024     try {
91025       delete arg1;
91026     } catch (std::out_of_range& e) {
91027       {
91028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91029       };
91030     } catch (std::exception& e) {
91031       {
91032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91033       };
91034     } catch (Dali::DaliException e) {
91035       {
91036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91037       };
91038     } catch (...) {
91039       {
91040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91041       };
91042     }
91043   }
91044
91045 }
91046
91047
91048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
91049   void * jresult ;
91050   Dali::Toolkit::PageFactory *arg1 = 0 ;
91051   Dali::Vector2 *arg2 = 0 ;
91052   Dali::Toolkit::PageTurnPortraitView result;
91053
91054   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
91055   if (!arg1) {
91056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
91057     return 0;
91058   }
91059   arg2 = (Dali::Vector2 *)jarg2;
91060   if (!arg2) {
91061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
91062     return 0;
91063   }
91064   {
91065     try {
91066       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
91067     } catch (std::out_of_range& e) {
91068       {
91069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91070       };
91071     } catch (std::exception& e) {
91072       {
91073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91074       };
91075     } catch (Dali::DaliException e) {
91076       {
91077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91078       };
91079     } catch (...) {
91080       {
91081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91082       };
91083     }
91084   }
91085
91086   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91087   return jresult;
91088 }
91089
91090
91091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
91092   void * jresult ;
91093   Dali::BaseHandle arg1 ;
91094   Dali::BaseHandle *argp1 ;
91095   Dali::Toolkit::PageTurnPortraitView result;
91096
91097   argp1 = (Dali::BaseHandle *)jarg1;
91098   if (!argp1) {
91099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91100     return 0;
91101   }
91102   arg1 = *argp1;
91103   {
91104     try {
91105       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
91106     } catch (std::out_of_range& e) {
91107       {
91108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91109       };
91110     } catch (std::exception& e) {
91111       {
91112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91113       };
91114     } catch (Dali::DaliException e) {
91115       {
91116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91117       };
91118     } catch (...) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91121       };
91122     }
91123   }
91124
91125   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
91126   return jresult;
91127 }
91128
91129
91130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
91131   int jresult ;
91132   int result;
91133
91134   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
91135   jresult = (int)result;
91136   return jresult;
91137 }
91138
91139
91140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
91141   int jresult ;
91142   int result;
91143
91144   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
91145   jresult = (int)result;
91146   return jresult;
91147 }
91148
91149
91150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
91151   int jresult ;
91152   int result;
91153
91154   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
91155   jresult = (int)result;
91156   return jresult;
91157 }
91158
91159
91160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
91161   void * jresult ;
91162   Dali::Toolkit::ToggleButton::Property *result = 0 ;
91163
91164   {
91165     try {
91166       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
91167     } catch (std::out_of_range& e) {
91168       {
91169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91170       };
91171     } catch (std::exception& e) {
91172       {
91173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91174       };
91175     } catch (Dali::DaliException e) {
91176       {
91177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91178       };
91179     } catch (...) {
91180       {
91181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91182       };
91183     }
91184   }
91185
91186   jresult = (void *)result;
91187   return jresult;
91188 }
91189
91190
91191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
91192   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
91193
91194   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
91195   {
91196     try {
91197       delete arg1;
91198     } catch (std::out_of_range& e) {
91199       {
91200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (std::exception& e) {
91203       {
91204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91205       };
91206     } catch (Dali::DaliException e) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91209       };
91210     } catch (...) {
91211       {
91212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91213       };
91214     }
91215   }
91216
91217 }
91218
91219
91220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
91221   void * jresult ;
91222   Dali::Toolkit::ToggleButton *result = 0 ;
91223
91224   {
91225     try {
91226       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
91227     } catch (std::out_of_range& e) {
91228       {
91229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91230       };
91231     } catch (std::exception& e) {
91232       {
91233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91234       };
91235     } catch (Dali::DaliException e) {
91236       {
91237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91238       };
91239     } catch (...) {
91240       {
91241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91242       };
91243     }
91244   }
91245
91246   jresult = (void *)result;
91247   return jresult;
91248 }
91249
91250
91251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
91252   void * jresult ;
91253   Dali::Toolkit::ToggleButton *arg1 = 0 ;
91254   Dali::Toolkit::ToggleButton *result = 0 ;
91255
91256   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91257   if (!arg1) {
91258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91259     return 0;
91260   }
91261   {
91262     try {
91263       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91271       };
91272     } catch (Dali::DaliException e) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91275       };
91276     } catch (...) {
91277       {
91278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91279       };
91280     }
91281   }
91282
91283   jresult = (void *)result;
91284   return jresult;
91285 }
91286
91287
91288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
91289   void * jresult ;
91290   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91291   Dali::Toolkit::ToggleButton *arg2 = 0 ;
91292   Dali::Toolkit::ToggleButton *result = 0 ;
91293
91294   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91295   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
91296   if (!arg2) {
91297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
91298     return 0;
91299   }
91300   {
91301     try {
91302       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
91303     } catch (std::out_of_range& e) {
91304       {
91305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91306       };
91307     } catch (std::exception& e) {
91308       {
91309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91310       };
91311     } catch (Dali::DaliException e) {
91312       {
91313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91314       };
91315     } catch (...) {
91316       {
91317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91318       };
91319     }
91320   }
91321
91322   jresult = (void *)result;
91323   return jresult;
91324 }
91325
91326
91327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
91328   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
91329
91330   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
91331   {
91332     try {
91333       delete arg1;
91334     } catch (std::out_of_range& e) {
91335       {
91336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91337       };
91338     } catch (std::exception& e) {
91339       {
91340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91341       };
91342     } catch (Dali::DaliException e) {
91343       {
91344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91345       };
91346     } catch (...) {
91347       {
91348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91349       };
91350     }
91351   }
91352
91353 }
91354
91355
91356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
91357   void * jresult ;
91358   Dali::Toolkit::ToggleButton result;
91359
91360   {
91361     try {
91362       result = Dali::Toolkit::ToggleButton::New();
91363     } catch (std::out_of_range& e) {
91364       {
91365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91366       };
91367     } catch (std::exception& e) {
91368       {
91369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91370       };
91371     } catch (Dali::DaliException e) {
91372       {
91373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91374       };
91375     } catch (...) {
91376       {
91377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91378       };
91379     }
91380   }
91381
91382   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91383   return jresult;
91384 }
91385
91386
91387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
91388   void * jresult ;
91389   Dali::BaseHandle arg1 ;
91390   Dali::BaseHandle *argp1 ;
91391   Dali::Toolkit::ToggleButton result;
91392
91393   argp1 = (Dali::BaseHandle *)jarg1;
91394   if (!argp1) {
91395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91396     return 0;
91397   }
91398   arg1 = *argp1;
91399   {
91400     try {
91401       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
91402     } catch (std::out_of_range& e) {
91403       {
91404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91405       };
91406     } catch (std::exception& e) {
91407       {
91408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91409       };
91410     } catch (Dali::DaliException e) {
91411       {
91412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91413       };
91414     } catch (...) {
91415       {
91416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91417       };
91418     }
91419   }
91420
91421   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
91422   return jresult;
91423 }
91424
91425
91426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
91427   void * jresult ;
91428   Dali::Toolkit::Visual::Base *result = 0 ;
91429
91430   {
91431     try {
91432       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
91433     } catch (std::out_of_range& e) {
91434       {
91435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91436       };
91437     } catch (std::exception& e) {
91438       {
91439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91440       };
91441     } catch (Dali::DaliException e) {
91442       {
91443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91444       };
91445     } catch (...) {
91446       {
91447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91448       };
91449     }
91450   }
91451
91452   jresult = (void *)result;
91453   return jresult;
91454 }
91455
91456
91457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
91458   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91459
91460   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91461   {
91462     try {
91463       delete arg1;
91464     } catch (std::out_of_range& e) {
91465       {
91466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91467       };
91468     } catch (std::exception& e) {
91469       {
91470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91471       };
91472     } catch (Dali::DaliException e) {
91473       {
91474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91475       };
91476     } catch (...) {
91477       {
91478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91479       };
91480     }
91481   }
91482
91483 }
91484
91485
91486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
91487   void * jresult ;
91488   Dali::Toolkit::Visual::Base *arg1 = 0 ;
91489   Dali::Toolkit::Visual::Base *result = 0 ;
91490
91491   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91492   if (!arg1) {
91493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91494     return 0;
91495   }
91496   {
91497     try {
91498       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
91499     } catch (std::out_of_range& e) {
91500       {
91501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91502       };
91503     } catch (std::exception& e) {
91504       {
91505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91506       };
91507     } catch (Dali::DaliException e) {
91508       {
91509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91510       };
91511     } catch (...) {
91512       {
91513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91514       };
91515     }
91516   }
91517
91518   jresult = (void *)result;
91519   return jresult;
91520 }
91521
91522
91523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
91524   void * jresult ;
91525   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91526   Dali::Toolkit::Visual::Base *arg2 = 0 ;
91527   Dali::Toolkit::Visual::Base *result = 0 ;
91528
91529   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91530   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
91531   if (!arg2) {
91532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
91533     return 0;
91534   }
91535   {
91536     try {
91537       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
91538     } catch (std::out_of_range& e) {
91539       {
91540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91541       };
91542     } catch (std::exception& e) {
91543       {
91544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91545       };
91546     } catch (Dali::DaliException e) {
91547       {
91548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91549       };
91550     } catch (...) {
91551       {
91552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91553       };
91554     }
91555   }
91556
91557   jresult = (void *)result;
91558   return jresult;
91559 }
91560
91561
91562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
91563   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91564   std::string *arg2 = 0 ;
91565
91566   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91567   if (!jarg2) {
91568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91569     return ;
91570   }
91571   std::string arg2_str(jarg2);
91572   arg2 = &arg2_str;
91573   {
91574     try {
91575       (arg1)->SetName((std::string const &)*arg2);
91576     } catch (std::out_of_range& e) {
91577       {
91578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91579       };
91580     } catch (std::exception& e) {
91581       {
91582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91583       };
91584     } catch (Dali::DaliException e) {
91585       {
91586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91587       };
91588     } catch (...) {
91589       {
91590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91591       };
91592     }
91593   }
91594
91595
91596   //argout typemap for const std::string&
91597
91598 }
91599
91600
91601 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
91602   char * jresult ;
91603   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91604   std::string *result = 0 ;
91605
91606   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91607   {
91608     try {
91609       result = (std::string *) &(arg1)->GetName();
91610     } catch (std::out_of_range& e) {
91611       {
91612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91613       };
91614     } catch (std::exception& e) {
91615       {
91616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91617       };
91618     } catch (Dali::DaliException e) {
91619       {
91620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91621       };
91622     } catch (...) {
91623       {
91624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91625       };
91626     }
91627   }
91628
91629   jresult = SWIG_csharp_string_callback(result->c_str());
91630   return jresult;
91631 }
91632
91633
91634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
91635   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91636   Dali::Property::Map *arg2 = 0 ;
91637   Dali::Size arg3 ;
91638   Dali::Size *argp3 ;
91639
91640   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91641   arg2 = (Dali::Property::Map *)jarg2;
91642   if (!arg2) {
91643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91644     return ;
91645   }
91646   argp3 = (Dali::Size *)jarg3;
91647   if (!argp3) {
91648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
91649     return ;
91650   }
91651   arg3 = *argp3;
91652   {
91653     try {
91654       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
91655     } catch (std::out_of_range& e) {
91656       {
91657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91658       };
91659     } catch (std::exception& e) {
91660       {
91661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91662       };
91663     } catch (Dali::DaliException e) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91666       };
91667     } catch (...) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91670       };
91671     }
91672   }
91673
91674 }
91675
91676
91677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
91678   float jresult ;
91679   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91680   float arg2 ;
91681   float result;
91682
91683   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91684   arg2 = (float)jarg2;
91685   {
91686     try {
91687       result = (float)(arg1)->GetHeightForWidth(arg2);
91688     } catch (std::out_of_range& e) {
91689       {
91690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91691       };
91692     } catch (std::exception& e) {
91693       {
91694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91695       };
91696     } catch (Dali::DaliException e) {
91697       {
91698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91699       };
91700     } catch (...) {
91701       {
91702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91703       };
91704     }
91705   }
91706
91707   jresult = result;
91708   return jresult;
91709 }
91710
91711
91712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
91713   float jresult ;
91714   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91715   float arg2 ;
91716   float result;
91717
91718   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91719   arg2 = (float)jarg2;
91720   {
91721     try {
91722       result = (float)(arg1)->GetWidthForHeight(arg2);
91723     } catch (std::out_of_range& e) {
91724       {
91725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91726       };
91727     } catch (std::exception& e) {
91728       {
91729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91730       };
91731     } catch (Dali::DaliException e) {
91732       {
91733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91734       };
91735     } catch (...) {
91736       {
91737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91738       };
91739     }
91740   }
91741
91742   jresult = result;
91743   return jresult;
91744 }
91745
91746
91747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
91748   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91749   Dali::Vector2 *arg2 = 0 ;
91750
91751   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91752   arg2 = (Dali::Vector2 *)jarg2;
91753   if (!arg2) {
91754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
91755     return ;
91756   }
91757   {
91758     try {
91759       (arg1)->GetNaturalSize(*arg2);
91760     } catch (std::out_of_range& e) {
91761       {
91762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91763       };
91764     } catch (std::exception& e) {
91765       {
91766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91767       };
91768     } catch (Dali::DaliException e) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91771       };
91772     } catch (...) {
91773       {
91774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91775       };
91776     }
91777   }
91778
91779 }
91780
91781
91782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
91783   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91784   float arg2 ;
91785
91786   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91787   arg2 = (int)jarg2;
91788   {
91789     try {
91790       (arg1)->SetDepthIndex(arg2);
91791     } catch (std::out_of_range& e) {
91792       {
91793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91794       };
91795     } catch (std::exception& e) {
91796       {
91797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91798       };
91799     } catch (Dali::DaliException e) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91802       };
91803     } catch (...) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91806       };
91807     }
91808   }
91809
91810 }
91811
91812
91813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91814   int jresult ;
91815   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91816   int result;
91817
91818   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91819   {
91820     try {
91821       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91822     } catch (std::out_of_range& e) {
91823       {
91824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91825       };
91826     } catch (std::exception& e) {
91827       {
91828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91829       };
91830     } catch (Dali::DaliException e) {
91831       {
91832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91833       };
91834     } catch (...) {
91835       {
91836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91837       };
91838     }
91839   }
91840
91841   jresult = result;
91842   return jresult;
91843 }
91844
91845
91846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91847   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91848   Dali::Property::Map *arg2 = 0 ;
91849
91850   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91851   arg2 = (Dali::Property::Map *)jarg2;
91852   if (!arg2) {
91853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91854     return ;
91855   }
91856   {
91857     try {
91858       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91859     } catch (std::out_of_range& e) {
91860       {
91861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91862       };
91863     } catch (std::exception& e) {
91864       {
91865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91866       };
91867     } catch (Dali::DaliException e) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91870       };
91871     } catch (...) {
91872       {
91873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91874       };
91875     }
91876   }
91877
91878 }
91879
91880
91881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_2(void * jarg1) {
91882   void * jresult ;
91883   Dali::Toolkit::Internal::Visual::Base *arg1 = (Dali::Toolkit::Internal::Visual::Base *) 0 ;
91884   Dali::Toolkit::Visual::Base *result = 0 ;
91885
91886   arg1 = (Dali::Toolkit::Internal::Visual::Base *)jarg1;
91887   {
91888     try {
91889       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base(arg1);
91890     } catch (std::out_of_range& e) {
91891       {
91892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91893       };
91894     } catch (std::exception& e) {
91895       {
91896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91897       };
91898     } catch (Dali::DaliException e) {
91899       {
91900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91901       };
91902     } catch (...) {
91903       {
91904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91905       };
91906     }
91907   }
91908
91909   jresult = (void *)result;
91910   return jresult;
91911 }
91912
91913
91914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91915   void * jresult ;
91916   Dali::Toolkit::VisualFactory result;
91917
91918   {
91919     try {
91920       result = Dali::Toolkit::VisualFactory::Get();
91921     } catch (std::out_of_range& e) {
91922       {
91923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91924       };
91925     } catch (std::exception& e) {
91926       {
91927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91928       };
91929     } catch (Dali::DaliException e) {
91930       {
91931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91932       };
91933     } catch (...) {
91934       {
91935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91936       };
91937     }
91938   }
91939
91940   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91941   return jresult;
91942 }
91943
91944
91945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91946   void * jresult ;
91947   Dali::Toolkit::VisualFactory *result = 0 ;
91948
91949   {
91950     try {
91951       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91952     } catch (std::out_of_range& e) {
91953       {
91954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91955       };
91956     } catch (std::exception& e) {
91957       {
91958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91959       };
91960     } catch (Dali::DaliException e) {
91961       {
91962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91963       };
91964     } catch (...) {
91965       {
91966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91967       };
91968     }
91969   }
91970
91971   jresult = (void *)result;
91972   return jresult;
91973 }
91974
91975
91976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91977   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91978
91979   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91980   {
91981     try {
91982       delete arg1;
91983     } catch (std::out_of_range& e) {
91984       {
91985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91986       };
91987     } catch (std::exception& e) {
91988       {
91989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91990       };
91991     } catch (Dali::DaliException e) {
91992       {
91993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91994       };
91995     } catch (...) {
91996       {
91997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91998       };
91999     }
92000   }
92001
92002 }
92003
92004
92005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
92006   void * jresult ;
92007   Dali::Toolkit::VisualFactory *arg1 = 0 ;
92008   Dali::Toolkit::VisualFactory *result = 0 ;
92009
92010   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92011   if (!arg1) {
92012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92013     return 0;
92014   }
92015   {
92016     try {
92017       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
92018     } catch (std::out_of_range& e) {
92019       {
92020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92021       };
92022     } catch (std::exception& e) {
92023       {
92024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92025       };
92026     } catch (Dali::DaliException e) {
92027       {
92028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92029       };
92030     } catch (...) {
92031       {
92032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92033       };
92034     }
92035   }
92036
92037   jresult = (void *)result;
92038   return jresult;
92039 }
92040
92041
92042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
92043   void * jresult ;
92044   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92045   Dali::Toolkit::VisualFactory *arg2 = 0 ;
92046   Dali::Toolkit::VisualFactory *result = 0 ;
92047
92048   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92049   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
92050   if (!arg2) {
92051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
92052     return 0;
92053   }
92054   {
92055     try {
92056       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
92057     } catch (std::out_of_range& e) {
92058       {
92059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92060       };
92061     } catch (std::exception& e) {
92062       {
92063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92064       };
92065     } catch (Dali::DaliException e) {
92066       {
92067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92068       };
92069     } catch (...) {
92070       {
92071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92072       };
92073     }
92074   }
92075
92076   jresult = (void *)result;
92077   return jresult;
92078 }
92079
92080
92081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
92082   void * jresult ;
92083   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92084   Dali::Property::Map *arg2 = 0 ;
92085   Dali::Toolkit::Visual::Base result;
92086
92087   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92088   arg2 = (Dali::Property::Map *)jarg2;
92089   if (!arg2) {
92090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
92091     return 0;
92092   }
92093   {
92094     try {
92095       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
92096     } catch (std::out_of_range& e) {
92097       {
92098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92099       };
92100     } catch (std::exception& e) {
92101       {
92102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92103       };
92104     } catch (Dali::DaliException e) {
92105       {
92106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92107       };
92108     } catch (...) {
92109       {
92110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92111       };
92112     }
92113   }
92114
92115   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92116   return jresult;
92117 }
92118
92119
92120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
92121   void * jresult ;
92122   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92123   Dali::Image *arg2 = 0 ;
92124   Dali::Toolkit::Visual::Base result;
92125
92126   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92127   arg2 = (Dali::Image *)jarg2;
92128   if (!arg2) {
92129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
92130     return 0;
92131   }
92132   {
92133     try {
92134       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
92135     } catch (std::out_of_range& e) {
92136       {
92137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92138       };
92139     } catch (std::exception& e) {
92140       {
92141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92142       };
92143     } catch (Dali::DaliException e) {
92144       {
92145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92146       };
92147     } catch (...) {
92148       {
92149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92150       };
92151     }
92152   }
92153
92154   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92155   return jresult;
92156 }
92157
92158
92159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
92160   void * jresult ;
92161   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
92162   std::string *arg2 = 0 ;
92163   Dali::ImageDimensions arg3 ;
92164   Dali::ImageDimensions *argp3 ;
92165   Dali::Toolkit::Visual::Base result;
92166
92167   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
92168   if (!jarg2) {
92169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92170     return 0;
92171   }
92172   std::string arg2_str(jarg2);
92173   arg2 = &arg2_str;
92174   argp3 = (Dali::ImageDimensions *)jarg3;
92175   if (!argp3) {
92176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92177     return 0;
92178   }
92179   arg3 = *argp3;
92180   {
92181     try {
92182       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
92183     } catch (std::out_of_range& e) {
92184       {
92185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (std::exception& e) {
92188       {
92189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92190       };
92191     } catch (Dali::DaliException e) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92194       };
92195     } catch (...) {
92196       {
92197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92198       };
92199     }
92200   }
92201
92202   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
92203
92204   //argout typemap for const std::string&
92205
92206   return jresult;
92207 }
92208
92209
92210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
92211   void * jresult ;
92212   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92213
92214   {
92215     try {
92216       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
92217     } catch (std::out_of_range& e) {
92218       {
92219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (std::exception& e) {
92222       {
92223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92224       };
92225     } catch (Dali::DaliException e) {
92226       {
92227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92228       };
92229     } catch (...) {
92230       {
92231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92232       };
92233     }
92234   }
92235
92236   jresult = (void *)result;
92237   return jresult;
92238 }
92239
92240
92241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
92242   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92243
92244   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92245   {
92246     try {
92247       delete arg1;
92248     } catch (std::out_of_range& e) {
92249       {
92250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92251       };
92252     } catch (std::exception& e) {
92253       {
92254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92255       };
92256     } catch (Dali::DaliException e) {
92257       {
92258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92259       };
92260     } catch (...) {
92261       {
92262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92263       };
92264     }
92265   }
92266
92267 }
92268
92269
92270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
92271   void * jresult ;
92272   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
92273   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92274
92275   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92276   if (!arg1) {
92277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92278     return 0;
92279   }
92280   {
92281     try {
92282       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
92283     } catch (std::out_of_range& e) {
92284       {
92285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92286       };
92287     } catch (std::exception& e) {
92288       {
92289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92290       };
92291     } catch (Dali::DaliException e) {
92292       {
92293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92294       };
92295     } catch (...) {
92296       {
92297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92298       };
92299     }
92300   }
92301
92302   jresult = (void *)result;
92303   return jresult;
92304 }
92305
92306
92307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
92308   void * jresult ;
92309   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92310   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
92311   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92312
92313   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92314   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
92315   if (!arg2) {
92316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
92317     return 0;
92318   }
92319   {
92320     try {
92321       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
92322     } catch (std::out_of_range& e) {
92323       {
92324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92325       };
92326     } catch (std::exception& e) {
92327       {
92328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92329       };
92330     } catch (Dali::DaliException e) {
92331       {
92332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92333       };
92334     } catch (...) {
92335       {
92336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92337       };
92338     }
92339   }
92340
92341   jresult = (void *)result;
92342   return jresult;
92343 }
92344
92345
92346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
92347   void * jresult ;
92348   Dali::Toolkit::AsyncImageLoader result;
92349
92350   {
92351     try {
92352       result = Dali::Toolkit::AsyncImageLoader::New();
92353     } catch (std::out_of_range& e) {
92354       {
92355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92356       };
92357     } catch (std::exception& e) {
92358       {
92359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92360       };
92361     } catch (Dali::DaliException e) {
92362       {
92363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92364       };
92365     } catch (...) {
92366       {
92367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92368       };
92369     }
92370   }
92371
92372   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92373   return jresult;
92374 }
92375
92376
92377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
92378   void * jresult ;
92379   Dali::BaseHandle arg1 ;
92380   Dali::BaseHandle *argp1 ;
92381   Dali::Toolkit::AsyncImageLoader result;
92382
92383   argp1 = (Dali::BaseHandle *)jarg1;
92384   if (!argp1) {
92385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
92386     return 0;
92387   }
92388   arg1 = *argp1;
92389   {
92390     try {
92391       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
92392     } catch (std::out_of_range& e) {
92393       {
92394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92395       };
92396     } catch (std::exception& e) {
92397       {
92398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92399       };
92400     } catch (Dali::DaliException e) {
92401       {
92402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92403       };
92404     } catch (...) {
92405       {
92406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92407       };
92408     }
92409   }
92410
92411   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
92412   return jresult;
92413 }
92414
92415
92416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
92417   unsigned int jresult ;
92418   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92419   std::string *arg2 = 0 ;
92420   uint32_t result;
92421
92422   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92423   if (!jarg2) {
92424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92425     return 0;
92426   }
92427   std::string arg2_str(jarg2);
92428   arg2 = &arg2_str;
92429   {
92430     try {
92431       result = (arg1)->Load((std::string const &)*arg2);
92432     } catch (std::out_of_range& e) {
92433       {
92434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92435       };
92436     } catch (std::exception& e) {
92437       {
92438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92439       };
92440     } catch (Dali::DaliException e) {
92441       {
92442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92443       };
92444     } catch (...) {
92445       {
92446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92447       };
92448     }
92449   }
92450
92451   jresult = result;
92452
92453   //argout typemap for const std::string&
92454
92455   return jresult;
92456 }
92457
92458
92459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
92460   unsigned int jresult ;
92461   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92462   std::string *arg2 = 0 ;
92463   Dali::ImageDimensions arg3 ;
92464   Dali::ImageDimensions *argp3 ;
92465   uint32_t result;
92466
92467   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92468   if (!jarg2) {
92469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92470     return 0;
92471   }
92472   std::string arg2_str(jarg2);
92473   arg2 = &arg2_str;
92474   argp3 = (Dali::ImageDimensions *)jarg3;
92475   if (!argp3) {
92476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92477     return 0;
92478   }
92479   arg3 = *argp3;
92480   {
92481     try {
92482       result = (arg1)->Load((std::string const &)*arg2,arg3);
92483     } catch (std::out_of_range& e) {
92484       {
92485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92486       };
92487     } catch (std::exception& e) {
92488       {
92489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92490       };
92491     } catch (Dali::DaliException e) {
92492       {
92493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92494       };
92495     } catch (...) {
92496       {
92497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92498       };
92499     }
92500   }
92501
92502   jresult = result;
92503
92504   //argout typemap for const std::string&
92505
92506   return jresult;
92507 }
92508
92509
92510 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
92511   unsigned int jresult ;
92512   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92513   std::string *arg2 = 0 ;
92514   Dali::ImageDimensions arg3 ;
92515   Dali::FittingMode::Type arg4 ;
92516   Dali::SamplingMode::Type arg5 ;
92517   bool arg6 ;
92518   Dali::ImageDimensions *argp3 ;
92519   uint32_t result;
92520
92521   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92522   if (!jarg2) {
92523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92524     return 0;
92525   }
92526   std::string arg2_str(jarg2);
92527   arg2 = &arg2_str;
92528   argp3 = (Dali::ImageDimensions *)jarg3;
92529   if (!argp3) {
92530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92531     return 0;
92532   }
92533   arg3 = *argp3;
92534   arg4 = (Dali::FittingMode::Type)jarg4;
92535   arg5 = (Dali::SamplingMode::Type)jarg5;
92536   arg6 = jarg6 ? true : false;
92537   {
92538     try {
92539       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
92540     } catch (std::out_of_range& e) {
92541       {
92542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92543       };
92544     } catch (std::exception& e) {
92545       {
92546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92547       };
92548     } catch (Dali::DaliException e) {
92549       {
92550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92551       };
92552     } catch (...) {
92553       {
92554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92555       };
92556     }
92557   }
92558
92559   jresult = result;
92560
92561   //argout typemap for const std::string&
92562
92563   return jresult;
92564 }
92565
92566
92567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
92568   unsigned int jresult ;
92569   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92570   uint32_t arg2 ;
92571   bool result;
92572
92573   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92574   arg2 = (uint32_t)jarg2;
92575   {
92576     try {
92577       result = (bool)(arg1)->Cancel(arg2);
92578     } catch (std::out_of_range& e) {
92579       {
92580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92581       };
92582     } catch (std::exception& e) {
92583       {
92584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92585       };
92586     } catch (Dali::DaliException e) {
92587       {
92588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92589       };
92590     } catch (...) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92593       };
92594     }
92595   }
92596
92597   jresult = result;
92598   return jresult;
92599 }
92600
92601
92602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
92603   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92604
92605   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92606   {
92607     try {
92608       (arg1)->CancelAll();
92609     } catch (std::out_of_range& e) {
92610       {
92611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92612       };
92613     } catch (std::exception& e) {
92614       {
92615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92616       };
92617     } catch (Dali::DaliException e) {
92618       {
92619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92620       };
92621     } catch (...) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92624       };
92625     }
92626   }
92627
92628 }
92629
92630
92631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
92632   void * jresult ;
92633   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
92634   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
92635
92636   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
92637   {
92638     try {
92639       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
92640     } catch (std::out_of_range& e) {
92641       {
92642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92643       };
92644     } catch (std::exception& e) {
92645       {
92646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92647       };
92648     } catch (Dali::DaliException e) {
92649       {
92650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92651       };
92652     } catch (...) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92655       };
92656     }
92657   }
92658
92659   jresult = (void *)result;
92660   return jresult;
92661 }
92662
92663
92664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_2(void * jarg1) {
92665   void * jresult ;
92666   Dali::Toolkit::Internal::AsyncImageLoader *arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *) 0 ;
92667   Dali::Toolkit::AsyncImageLoader *result = 0 ;
92668
92669   arg1 = (Dali::Toolkit::Internal::AsyncImageLoader *)jarg1;
92670   {
92671     try {
92672       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader(arg1);
92673     } catch (std::out_of_range& e) {
92674       {
92675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92676       };
92677     } catch (std::exception& e) {
92678       {
92679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92680       };
92681     } catch (Dali::DaliException e) {
92682       {
92683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92684       };
92685     } catch (...) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92688       };
92689     }
92690   }
92691
92692   jresult = (void *)result;
92693   return jresult;
92694 }
92695
92696
92697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
92698   void * jresult ;
92699   std::string *arg1 = 0 ;
92700   Dali::PixelData result;
92701
92702   if (!jarg1) {
92703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92704     return 0;
92705   }
92706   std::string arg1_str(jarg1);
92707   arg1 = &arg1_str;
92708   {
92709     try {
92710       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
92711     } catch (std::out_of_range& e) {
92712       {
92713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92714       };
92715     } catch (std::exception& e) {
92716       {
92717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92718       };
92719     } catch (Dali::DaliException e) {
92720       {
92721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92722       };
92723     } catch (...) {
92724       {
92725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92726       };
92727     }
92728   }
92729
92730   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92731
92732   //argout typemap for const std::string&
92733
92734   return jresult;
92735 }
92736
92737
92738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
92739   void * jresult ;
92740   std::string *arg1 = 0 ;
92741   Dali::ImageDimensions arg2 ;
92742   Dali::ImageDimensions *argp2 ;
92743   Dali::PixelData result;
92744
92745   if (!jarg1) {
92746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92747     return 0;
92748   }
92749   std::string arg1_str(jarg1);
92750   arg1 = &arg1_str;
92751   argp2 = (Dali::ImageDimensions *)jarg2;
92752   if (!argp2) {
92753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92754     return 0;
92755   }
92756   arg2 = *argp2;
92757   {
92758     try {
92759       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
92760     } catch (std::out_of_range& e) {
92761       {
92762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92763       };
92764     } catch (std::exception& e) {
92765       {
92766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92767       };
92768     } catch (Dali::DaliException e) {
92769       {
92770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92771       };
92772     } catch (...) {
92773       {
92774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92775       };
92776     }
92777   }
92778
92779   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92780
92781   //argout typemap for const std::string&
92782
92783   return jresult;
92784 }
92785
92786
92787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
92788   void * jresult ;
92789   std::string *arg1 = 0 ;
92790   Dali::ImageDimensions arg2 ;
92791   Dali::FittingMode::Type arg3 ;
92792   Dali::SamplingMode::Type arg4 ;
92793   bool arg5 ;
92794   Dali::ImageDimensions *argp2 ;
92795   Dali::PixelData result;
92796
92797   if (!jarg1) {
92798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
92799     return 0;
92800   }
92801   std::string arg1_str(jarg1);
92802   arg1 = &arg1_str;
92803   argp2 = (Dali::ImageDimensions *)jarg2;
92804   if (!argp2) {
92805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
92806     return 0;
92807   }
92808   arg2 = *argp2;
92809   arg3 = (Dali::FittingMode::Type)jarg3;
92810   arg4 = (Dali::SamplingMode::Type)jarg4;
92811   arg5 = jarg5 ? true : false;
92812   {
92813     try {
92814       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
92815     } catch (std::out_of_range& e) {
92816       {
92817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92818       };
92819     } catch (std::exception& e) {
92820       {
92821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92822       };
92823     } catch (Dali::DaliException e) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92826       };
92827     } catch (...) {
92828       {
92829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92830       };
92831     }
92832   }
92833
92834   jresult = new Dali::PixelData((const Dali::PixelData &)result);
92835
92836   //argout typemap for const std::string&
92837
92838   return jresult;
92839 }
92840
92841
92842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
92843   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92844
92845   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92846   {
92847     try {
92848       delete arg1;
92849     } catch (std::out_of_range& e) {
92850       {
92851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92852       };
92853     } catch (std::exception& e) {
92854       {
92855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92856       };
92857     } catch (Dali::DaliException e) {
92858       {
92859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92860       };
92861     } catch (...) {
92862       {
92863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92864       };
92865     }
92866   }
92867
92868 }
92869
92870
92871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92872   void * jresult ;
92873   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92874   Dali::Actor arg2 ;
92875   Dali::Actor arg3 ;
92876   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92877   Dali::Actor *argp2 ;
92878   Dali::Actor *argp3 ;
92879   Dali::Actor result;
92880
92881   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92882   argp2 = (Dali::Actor *)jarg2;
92883   if (!argp2) {
92884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92885     return 0;
92886   }
92887   arg2 = *argp2;
92888   argp3 = (Dali::Actor *)jarg3;
92889   if (!argp3) {
92890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92891     return 0;
92892   }
92893   arg3 = *argp3;
92894   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92895   {
92896     try {
92897       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92898     } catch (std::out_of_range& e) {
92899       {
92900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92901       };
92902     } catch (std::exception& e) {
92903       {
92904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92905       };
92906     } catch (Dali::DaliException e) {
92907       {
92908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92909       };
92910     } catch (...) {
92911       {
92912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92913       };
92914     }
92915   }
92916
92917   jresult = new Dali::Actor((const Dali::Actor &)result);
92918   return jresult;
92919 }
92920
92921
92922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92923   void * jresult ;
92924   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92925
92926   {
92927     try {
92928       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92929     } catch (std::out_of_range& e) {
92930       {
92931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92932       };
92933     } catch (std::exception& e) {
92934       {
92935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92936       };
92937     } catch (Dali::DaliException e) {
92938       {
92939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92940       };
92941     } catch (...) {
92942       {
92943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92944       };
92945     }
92946   }
92947
92948   jresult = (void *)result;
92949   return jresult;
92950 }
92951
92952
92953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92954   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92955   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92956   if (director) {
92957     director->swig_connect_director(callback0);
92958   }
92959 }
92960
92961
92962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92963   KeyboardFocusManager arg1 ;
92964   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92965   KeyboardFocusManager *argp1 ;
92966
92967   argp1 = (KeyboardFocusManager *)jarg1;
92968   if (!argp1) {
92969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92970     return ;
92971   }
92972   arg1 = *argp1;
92973   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92974   if (!arg2) {
92975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92976     return ;
92977   }
92978   {
92979     try {
92980       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92981     } catch (std::out_of_range& e) {
92982       {
92983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92984       };
92985     } catch (std::exception& e) {
92986       {
92987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92988       };
92989     } catch (Dali::DaliException e) {
92990       {
92991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92992       };
92993     } catch (...) {
92994       {
92995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92996       };
92997     }
92998   }
92999
93000 }
93001
93002
93003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
93004   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93005
93006   arg1 = (std::vector< unsigned int > *)jarg1;
93007   {
93008     try {
93009       (arg1)->clear();
93010     } catch (std::out_of_range& e) {
93011       {
93012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93013       };
93014     } catch (std::exception& e) {
93015       {
93016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93017       };
93018     } catch (Dali::DaliException e) {
93019       {
93020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93021       };
93022     } catch (...) {
93023       {
93024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93025       };
93026     }
93027   }
93028
93029 }
93030
93031
93032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
93033   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93034   unsigned int *arg2 = 0 ;
93035   unsigned int temp2 ;
93036
93037   arg1 = (std::vector< unsigned int > *)jarg1;
93038   temp2 = (unsigned int)jarg2;
93039   arg2 = &temp2;
93040   {
93041     try {
93042       (arg1)->push_back((unsigned int const &)*arg2);
93043     } catch (std::out_of_range& e) {
93044       {
93045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93046       };
93047     } catch (std::exception& e) {
93048       {
93049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93050       };
93051     } catch (Dali::DaliException e) {
93052       {
93053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93054       };
93055     } catch (...) {
93056       {
93057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93058       };
93059     }
93060   }
93061
93062 }
93063
93064
93065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
93066   unsigned long jresult ;
93067   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93068   std::vector< unsigned int >::size_type result;
93069
93070   arg1 = (std::vector< unsigned int > *)jarg1;
93071   {
93072     try {
93073       result = ((std::vector< unsigned int > const *)arg1)->size();
93074     } catch (std::out_of_range& e) {
93075       {
93076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93077       };
93078     } catch (std::exception& e) {
93079       {
93080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93081       };
93082     } catch (Dali::DaliException e) {
93083       {
93084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93085       };
93086     } catch (...) {
93087       {
93088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93089       };
93090     }
93091   }
93092
93093   jresult = (unsigned long)result;
93094   return jresult;
93095 }
93096
93097
93098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
93099   unsigned long jresult ;
93100   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93101   std::vector< unsigned int >::size_type result;
93102
93103   arg1 = (std::vector< unsigned int > *)jarg1;
93104   {
93105     try {
93106       result = ((std::vector< unsigned int > const *)arg1)->capacity();
93107     } catch (std::out_of_range& e) {
93108       {
93109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93110       };
93111     } catch (std::exception& e) {
93112       {
93113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93114       };
93115     } catch (Dali::DaliException e) {
93116       {
93117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93118       };
93119     } catch (...) {
93120       {
93121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93122       };
93123     }
93124   }
93125
93126   jresult = (unsigned long)result;
93127   return jresult;
93128 }
93129
93130
93131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
93132   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93133   std::vector< unsigned int >::size_type arg2 ;
93134
93135   arg1 = (std::vector< unsigned int > *)jarg1;
93136   arg2 = (std::vector< unsigned int >::size_type)jarg2;
93137   {
93138     try {
93139       (arg1)->reserve(arg2);
93140     } catch (std::out_of_range& e) {
93141       {
93142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93143       };
93144     } catch (std::exception& e) {
93145       {
93146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93147       };
93148     } catch (Dali::DaliException e) {
93149       {
93150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93151       };
93152     } catch (...) {
93153       {
93154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93155       };
93156     }
93157   }
93158
93159 }
93160
93161
93162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
93163   void * jresult ;
93164   std::vector< unsigned int > *result = 0 ;
93165
93166   {
93167     try {
93168       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
93169     } catch (std::out_of_range& e) {
93170       {
93171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93172       };
93173     } catch (std::exception& e) {
93174       {
93175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93176       };
93177     } catch (Dali::DaliException e) {
93178       {
93179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93180       };
93181     } catch (...) {
93182       {
93183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93184       };
93185     }
93186   }
93187
93188   jresult = (void *)result;
93189   return jresult;
93190 }
93191
93192
93193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
93194   void * jresult ;
93195   std::vector< unsigned int > *arg1 = 0 ;
93196   std::vector< unsigned int > *result = 0 ;
93197
93198   arg1 = (std::vector< unsigned int > *)jarg1;
93199   if (!arg1) {
93200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93201     return 0;
93202   }
93203   {
93204     try {
93205       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
93206     } catch (std::out_of_range& e) {
93207       {
93208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93209       };
93210     } catch (std::exception& e) {
93211       {
93212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93213       };
93214     } catch (Dali::DaliException e) {
93215       {
93216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93217       };
93218     } catch (...) {
93219       {
93220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93221       };
93222     }
93223   }
93224
93225   jresult = (void *)result;
93226   return jresult;
93227 }
93228
93229
93230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
93231   void * jresult ;
93232   int arg1 ;
93233   std::vector< unsigned int > *result = 0 ;
93234
93235   arg1 = (int)jarg1;
93236   {
93237     try {
93238       try {
93239         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
93240       }
93241       catch(std::out_of_range &_e) {
93242         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93243         return 0;
93244       }
93245
93246     } catch (std::out_of_range& e) {
93247       {
93248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93249       };
93250     } catch (std::exception& e) {
93251       {
93252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93253       };
93254     } catch (Dali::DaliException e) {
93255       {
93256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93257       };
93258     } catch (...) {
93259       {
93260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93261       };
93262     }
93263   }
93264
93265   jresult = (void *)result;
93266   return jresult;
93267 }
93268
93269
93270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
93271   unsigned int jresult ;
93272   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93273   int arg2 ;
93274   unsigned int result;
93275
93276   arg1 = (std::vector< unsigned int > *)jarg1;
93277   arg2 = (int)jarg2;
93278   {
93279     try {
93280       try {
93281         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
93282       }
93283       catch(std::out_of_range &_e) {
93284         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93285         return 0;
93286       }
93287
93288     } catch (std::out_of_range& e) {
93289       {
93290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93291       };
93292     } catch (std::exception& e) {
93293       {
93294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93295       };
93296     } catch (Dali::DaliException e) {
93297       {
93298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93299       };
93300     } catch (...) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93303       };
93304     }
93305   }
93306
93307   jresult = result;
93308   return jresult;
93309 }
93310
93311
93312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
93313   unsigned int jresult ;
93314   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93315   int arg2 ;
93316   unsigned int *result = 0 ;
93317
93318   arg1 = (std::vector< unsigned int > *)jarg1;
93319   arg2 = (int)jarg2;
93320   {
93321     try {
93322       try {
93323         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
93324       }
93325       catch(std::out_of_range &_e) {
93326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93327         return 0;
93328       }
93329
93330     } catch (std::out_of_range& e) {
93331       {
93332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93333       };
93334     } catch (std::exception& e) {
93335       {
93336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93337       };
93338     } catch (Dali::DaliException e) {
93339       {
93340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93341       };
93342     } catch (...) {
93343       {
93344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93345       };
93346     }
93347   }
93348
93349   jresult = *result;
93350   return jresult;
93351 }
93352
93353
93354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
93355   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93356   int arg2 ;
93357   unsigned int *arg3 = 0 ;
93358   unsigned int temp3 ;
93359
93360   arg1 = (std::vector< unsigned int > *)jarg1;
93361   arg2 = (int)jarg2;
93362   temp3 = (unsigned int)jarg3;
93363   arg3 = &temp3;
93364   {
93365     try {
93366       try {
93367         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
93368       }
93369       catch(std::out_of_range &_e) {
93370         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93371         return ;
93372       }
93373
93374     } catch (std::out_of_range& e) {
93375       {
93376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93377       };
93378     } catch (std::exception& e) {
93379       {
93380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93381       };
93382     } catch (Dali::DaliException e) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93385       };
93386     } catch (...) {
93387       {
93388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93389       };
93390     }
93391   }
93392
93393 }
93394
93395
93396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
93397   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93398   std::vector< unsigned int > *arg2 = 0 ;
93399
93400   arg1 = (std::vector< unsigned int > *)jarg1;
93401   arg2 = (std::vector< unsigned int > *)jarg2;
93402   if (!arg2) {
93403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93404     return ;
93405   }
93406   {
93407     try {
93408       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
93409     } catch (std::out_of_range& e) {
93410       {
93411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93412       };
93413     } catch (std::exception& e) {
93414       {
93415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93416       };
93417     } catch (Dali::DaliException e) {
93418       {
93419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93420       };
93421     } catch (...) {
93422       {
93423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93424       };
93425     }
93426   }
93427
93428 }
93429
93430
93431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93432   void * jresult ;
93433   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93434   int arg2 ;
93435   int arg3 ;
93436   std::vector< unsigned int > *result = 0 ;
93437
93438   arg1 = (std::vector< unsigned int > *)jarg1;
93439   arg2 = (int)jarg2;
93440   arg3 = (int)jarg3;
93441   {
93442     try {
93443       try {
93444         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
93445       }
93446       catch(std::out_of_range &_e) {
93447         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93448         return 0;
93449       }
93450       catch(std::invalid_argument &_e) {
93451         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93452         return 0;
93453       }
93454
93455     } catch (std::out_of_range& e) {
93456       {
93457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93458       };
93459     } catch (std::exception& e) {
93460       {
93461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93462       };
93463     } catch (Dali::DaliException e) {
93464       {
93465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93466       };
93467     } catch (...) {
93468       {
93469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93470       };
93471     }
93472   }
93473
93474   jresult = (void *)result;
93475   return jresult;
93476 }
93477
93478
93479 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
93480   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93481   int arg2 ;
93482   unsigned int *arg3 = 0 ;
93483   unsigned int temp3 ;
93484
93485   arg1 = (std::vector< unsigned int > *)jarg1;
93486   arg2 = (int)jarg2;
93487   temp3 = (unsigned int)jarg3;
93488   arg3 = &temp3;
93489   {
93490     try {
93491       try {
93492         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
93493       }
93494       catch(std::out_of_range &_e) {
93495         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93496         return ;
93497       }
93498
93499     } catch (std::out_of_range& e) {
93500       {
93501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93502       };
93503     } catch (std::exception& e) {
93504       {
93505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93506       };
93507     } catch (Dali::DaliException e) {
93508       {
93509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93510       };
93511     } catch (...) {
93512       {
93513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93514       };
93515     }
93516   }
93517
93518 }
93519
93520
93521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93522   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93523   int arg2 ;
93524   std::vector< unsigned int > *arg3 = 0 ;
93525
93526   arg1 = (std::vector< unsigned int > *)jarg1;
93527   arg2 = (int)jarg2;
93528   arg3 = (std::vector< unsigned int > *)jarg3;
93529   if (!arg3) {
93530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93531     return ;
93532   }
93533   {
93534     try {
93535       try {
93536         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93537       }
93538       catch(std::out_of_range &_e) {
93539         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93540         return ;
93541       }
93542
93543     } catch (std::out_of_range& e) {
93544       {
93545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93546       };
93547     } catch (std::exception& e) {
93548       {
93549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93550       };
93551     } catch (Dali::DaliException e) {
93552       {
93553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93554       };
93555     } catch (...) {
93556       {
93557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93558       };
93559     }
93560   }
93561
93562 }
93563
93564
93565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
93566   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93567   int arg2 ;
93568
93569   arg1 = (std::vector< unsigned int > *)jarg1;
93570   arg2 = (int)jarg2;
93571   {
93572     try {
93573       try {
93574         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
93575       }
93576       catch(std::out_of_range &_e) {
93577         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93578         return ;
93579       }
93580
93581     } catch (std::out_of_range& e) {
93582       {
93583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93584       };
93585     } catch (std::exception& e) {
93586       {
93587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93588       };
93589     } catch (Dali::DaliException e) {
93590       {
93591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93592       };
93593     } catch (...) {
93594       {
93595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93596       };
93597     }
93598   }
93599
93600 }
93601
93602
93603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93604   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93605   int arg2 ;
93606   int arg3 ;
93607
93608   arg1 = (std::vector< unsigned int > *)jarg1;
93609   arg2 = (int)jarg2;
93610   arg3 = (int)jarg3;
93611   {
93612     try {
93613       try {
93614         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
93615       }
93616       catch(std::out_of_range &_e) {
93617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93618         return ;
93619       }
93620       catch(std::invalid_argument &_e) {
93621         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93622         return ;
93623       }
93624
93625     } catch (std::out_of_range& e) {
93626       {
93627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93628       };
93629     } catch (std::exception& e) {
93630       {
93631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93632       };
93633     } catch (Dali::DaliException e) {
93634       {
93635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93636       };
93637     } catch (...) {
93638       {
93639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93640       };
93641     }
93642   }
93643
93644 }
93645
93646
93647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
93648   void * jresult ;
93649   unsigned int *arg1 = 0 ;
93650   int arg2 ;
93651   unsigned int temp1 ;
93652   std::vector< unsigned int > *result = 0 ;
93653
93654   temp1 = (unsigned int)jarg1;
93655   arg1 = &temp1;
93656   arg2 = (int)jarg2;
93657   {
93658     try {
93659       try {
93660         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
93661       }
93662       catch(std::out_of_range &_e) {
93663         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93664         return 0;
93665       }
93666
93667     } catch (std::out_of_range& e) {
93668       {
93669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93670       };
93671     } catch (std::exception& e) {
93672       {
93673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93674       };
93675     } catch (Dali::DaliException e) {
93676       {
93677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93678       };
93679     } catch (...) {
93680       {
93681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93682       };
93683     }
93684   }
93685
93686   jresult = (void *)result;
93687   return jresult;
93688 }
93689
93690
93691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
93692   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93693
93694   arg1 = (std::vector< unsigned int > *)jarg1;
93695   {
93696     try {
93697       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
93698     } catch (std::out_of_range& e) {
93699       {
93700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93701       };
93702     } catch (std::exception& e) {
93703       {
93704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93705       };
93706     } catch (Dali::DaliException e) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93709       };
93710     } catch (...) {
93711       {
93712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93713       };
93714     }
93715   }
93716
93717 }
93718
93719
93720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93721   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93722   int arg2 ;
93723   int arg3 ;
93724
93725   arg1 = (std::vector< unsigned int > *)jarg1;
93726   arg2 = (int)jarg2;
93727   arg3 = (int)jarg3;
93728   {
93729     try {
93730       try {
93731         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
93732       }
93733       catch(std::out_of_range &_e) {
93734         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93735         return ;
93736       }
93737       catch(std::invalid_argument &_e) {
93738         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93739         return ;
93740       }
93741
93742     } catch (std::out_of_range& e) {
93743       {
93744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93745       };
93746     } catch (std::exception& e) {
93747       {
93748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93749       };
93750     } catch (Dali::DaliException e) {
93751       {
93752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93753       };
93754     } catch (...) {
93755       {
93756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93757       };
93758     }
93759   }
93760
93761 }
93762
93763
93764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
93765   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93766   int arg2 ;
93767   std::vector< unsigned int > *arg3 = 0 ;
93768
93769   arg1 = (std::vector< unsigned int > *)jarg1;
93770   arg2 = (int)jarg2;
93771   arg3 = (std::vector< unsigned int > *)jarg3;
93772   if (!arg3) {
93773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
93774     return ;
93775   }
93776   {
93777     try {
93778       try {
93779         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
93780       }
93781       catch(std::out_of_range &_e) {
93782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93783         return ;
93784       }
93785
93786     } catch (std::out_of_range& e) {
93787       {
93788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93789       };
93790     } catch (std::exception& e) {
93791       {
93792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93793       };
93794     } catch (Dali::DaliException e) {
93795       {
93796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93797       };
93798     } catch (...) {
93799       {
93800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93801       };
93802     }
93803   }
93804
93805 }
93806
93807
93808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
93809   unsigned int jresult ;
93810   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93811   unsigned int *arg2 = 0 ;
93812   unsigned int temp2 ;
93813   bool result;
93814
93815   arg1 = (std::vector< unsigned int > *)jarg1;
93816   temp2 = (unsigned int)jarg2;
93817   arg2 = &temp2;
93818   {
93819     try {
93820       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
93821     } catch (std::out_of_range& e) {
93822       {
93823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93824       };
93825     } catch (std::exception& e) {
93826       {
93827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93828       };
93829     } catch (Dali::DaliException e) {
93830       {
93831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93832       };
93833     } catch (...) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93836       };
93837     }
93838   }
93839
93840   jresult = result;
93841   return jresult;
93842 }
93843
93844
93845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
93846   int jresult ;
93847   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93848   unsigned int *arg2 = 0 ;
93849   unsigned int temp2 ;
93850   int result;
93851
93852   arg1 = (std::vector< unsigned int > *)jarg1;
93853   temp2 = (unsigned int)jarg2;
93854   arg2 = &temp2;
93855   {
93856     try {
93857       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
93858     } catch (std::out_of_range& e) {
93859       {
93860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93861       };
93862     } catch (std::exception& e) {
93863       {
93864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93865       };
93866     } catch (Dali::DaliException e) {
93867       {
93868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93869       };
93870     } catch (...) {
93871       {
93872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93873       };
93874     }
93875   }
93876
93877   jresult = result;
93878   return jresult;
93879 }
93880
93881
93882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93883   int jresult ;
93884   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93885   unsigned int *arg2 = 0 ;
93886   unsigned int temp2 ;
93887   int result;
93888
93889   arg1 = (std::vector< unsigned int > *)jarg1;
93890   temp2 = (unsigned int)jarg2;
93891   arg2 = &temp2;
93892   {
93893     try {
93894       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93895     } catch (std::out_of_range& e) {
93896       {
93897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93898       };
93899     } catch (std::exception& e) {
93900       {
93901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93902       };
93903     } catch (Dali::DaliException e) {
93904       {
93905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93906       };
93907     } catch (...) {
93908       {
93909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93910       };
93911     }
93912   }
93913
93914   jresult = result;
93915   return jresult;
93916 }
93917
93918
93919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93920   unsigned int jresult ;
93921   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93922   unsigned int *arg2 = 0 ;
93923   unsigned int temp2 ;
93924   bool result;
93925
93926   arg1 = (std::vector< unsigned int > *)jarg1;
93927   temp2 = (unsigned int)jarg2;
93928   arg2 = &temp2;
93929   {
93930     try {
93931       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93932     } catch (std::out_of_range& e) {
93933       {
93934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93935       };
93936     } catch (std::exception& e) {
93937       {
93938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93939       };
93940     } catch (Dali::DaliException e) {
93941       {
93942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93943       };
93944     } catch (...) {
93945       {
93946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93947       };
93948     }
93949   }
93950
93951   jresult = result;
93952   return jresult;
93953 }
93954
93955
93956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93957   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93958
93959   arg1 = (std::vector< unsigned int > *)jarg1;
93960   {
93961     try {
93962       delete arg1;
93963     } catch (std::out_of_range& e) {
93964       {
93965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93966       };
93967     } catch (std::exception& e) {
93968       {
93969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93970       };
93971     } catch (Dali::DaliException e) {
93972       {
93973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93974       };
93975     } catch (...) {
93976       {
93977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93978       };
93979     }
93980   }
93981
93982 }
93983
93984
93985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93986   void * jresult ;
93987   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93988
93989   {
93990     try {
93991       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93992     } catch (std::out_of_range& e) {
93993       {
93994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93995       };
93996     } catch (std::exception& e) {
93997       {
93998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93999       };
94000     } catch (Dali::DaliException e) {
94001       {
94002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94003       };
94004     } catch (...) {
94005       {
94006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94007       };
94008     }
94009   }
94010
94011   jresult = (void *)result;
94012   return jresult;
94013 }
94014
94015
94016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
94017   void * jresult ;
94018   unsigned int arg1 ;
94019   Dali::Actor arg2 ;
94020   Dali::Actor *argp2 ;
94021   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94022
94023   arg1 = (unsigned int)jarg1;
94024   argp2 = (Dali::Actor *)jarg2;
94025   if (!argp2) {
94026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
94027     return 0;
94028   }
94029   arg2 = *argp2;
94030   {
94031     try {
94032       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
94033     } catch (std::out_of_range& e) {
94034       {
94035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94036       };
94037     } catch (std::exception& e) {
94038       {
94039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94040       };
94041     } catch (Dali::DaliException e) {
94042       {
94043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94044       };
94045     } catch (...) {
94046       {
94047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94048       };
94049     }
94050   }
94051
94052   jresult = (void *)result;
94053   return jresult;
94054 }
94055
94056
94057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
94058   void * jresult ;
94059   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94060   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94061
94062   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94063   if (!arg1) {
94064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94065     return 0;
94066   }
94067   {
94068     try {
94069       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
94070     } catch (std::out_of_range& e) {
94071       {
94072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94073       };
94074     } catch (std::exception& e) {
94075       {
94076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94077       };
94078     } catch (Dali::DaliException e) {
94079       {
94080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94081       };
94082     } catch (...) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94085       };
94086     }
94087   }
94088
94089   jresult = (void *)result;
94090   return jresult;
94091 }
94092
94093
94094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
94095   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94096   unsigned int arg2 ;
94097
94098   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94099   arg2 = (unsigned int)jarg2;
94100   if (arg1) (arg1)->first = arg2;
94101 }
94102
94103
94104 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
94105   unsigned int jresult ;
94106   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94107   unsigned int result;
94108
94109   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94110   result = (unsigned int) ((arg1)->first);
94111   jresult = result;
94112   return jresult;
94113 }
94114
94115
94116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
94117   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94118   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
94119
94120   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94121   arg2 = (Dali::Actor *)jarg2;
94122   if (arg1) (arg1)->second = *arg2;
94123 }
94124
94125
94126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
94127   void * jresult ;
94128   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94129   Dali::Actor *result = 0 ;
94130
94131   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94132   result = (Dali::Actor *)& ((arg1)->second);
94133   jresult = (void *)result;
94134   return jresult;
94135 }
94136
94137
94138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
94139   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
94140
94141   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94142   {
94143     try {
94144       delete arg1;
94145     } catch (std::out_of_range& e) {
94146       {
94147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94148       };
94149     } catch (std::exception& e) {
94150       {
94151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94152       };
94153     } catch (Dali::DaliException e) {
94154       {
94155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94156       };
94157     } catch (...) {
94158       {
94159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94160       };
94161     }
94162   }
94163
94164 }
94165
94166
94167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
94168   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94169
94170   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94171   {
94172     try {
94173       (arg1)->clear();
94174     } catch (std::out_of_range& e) {
94175       {
94176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94177       };
94178     } catch (std::exception& e) {
94179       {
94180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94181       };
94182     } catch (Dali::DaliException e) {
94183       {
94184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94185       };
94186     } catch (...) {
94187       {
94188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94189       };
94190     }
94191   }
94192
94193 }
94194
94195
94196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
94197   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94198   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
94199
94200   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94201   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
94202   if (!arg2) {
94203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94204     return ;
94205   }
94206   {
94207     try {
94208       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
94209     } catch (std::out_of_range& e) {
94210       {
94211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94212       };
94213     } catch (std::exception& e) {
94214       {
94215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94216       };
94217     } catch (Dali::DaliException e) {
94218       {
94219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94220       };
94221     } catch (...) {
94222       {
94223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94224       };
94225     }
94226   }
94227
94228 }
94229
94230
94231 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
94232   unsigned long jresult ;
94233   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94234   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94235
94236   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94237   {
94238     try {
94239       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
94240     } catch (std::out_of_range& e) {
94241       {
94242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94243       };
94244     } catch (std::exception& e) {
94245       {
94246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94247       };
94248     } catch (Dali::DaliException e) {
94249       {
94250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94251       };
94252     } catch (...) {
94253       {
94254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94255       };
94256     }
94257   }
94258
94259   jresult = (unsigned long)result;
94260   return jresult;
94261 }
94262
94263
94264 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
94265   unsigned long jresult ;
94266   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94267   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
94268
94269   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94270   {
94271     try {
94272       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
94273     } catch (std::out_of_range& e) {
94274       {
94275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94276       };
94277     } catch (std::exception& e) {
94278       {
94279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94280       };
94281     } catch (Dali::DaliException e) {
94282       {
94283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94284       };
94285     } catch (...) {
94286       {
94287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94288       };
94289     }
94290   }
94291
94292   jresult = (unsigned long)result;
94293   return jresult;
94294 }
94295
94296
94297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
94298   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94299   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
94300
94301   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94302   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
94303   {
94304     try {
94305       (arg1)->reserve(arg2);
94306     } catch (std::out_of_range& e) {
94307       {
94308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94309       };
94310     } catch (std::exception& e) {
94311       {
94312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94313       };
94314     } catch (Dali::DaliException e) {
94315       {
94316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94317       };
94318     } catch (...) {
94319       {
94320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94321       };
94322     }
94323   }
94324
94325 }
94326
94327
94328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
94329   void * jresult ;
94330   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94331
94332   {
94333     try {
94334       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
94335     } catch (std::out_of_range& e) {
94336       {
94337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94338       };
94339     } catch (std::exception& e) {
94340       {
94341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94342       };
94343     } catch (Dali::DaliException e) {
94344       {
94345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94346       };
94347     } catch (...) {
94348       {
94349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94350       };
94351     }
94352   }
94353
94354   jresult = (void *)result;
94355   return jresult;
94356 }
94357
94358
94359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
94360   void * jresult ;
94361   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
94362   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94363
94364   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94365   if (!arg1) {
94366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94367     return 0;
94368   }
94369   {
94370     try {
94371       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);
94372     } catch (std::out_of_range& e) {
94373       {
94374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94375       };
94376     } catch (std::exception& e) {
94377       {
94378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94379       };
94380     } catch (Dali::DaliException e) {
94381       {
94382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94383       };
94384     } catch (...) {
94385       {
94386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94387       };
94388     }
94389   }
94390
94391   jresult = (void *)result;
94392   return jresult;
94393 }
94394
94395
94396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
94397   void * jresult ;
94398   int arg1 ;
94399   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94400
94401   arg1 = (int)jarg1;
94402   {
94403     try {
94404       try {
94405         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);
94406       }
94407       catch(std::out_of_range &_e) {
94408         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94409         return 0;
94410       }
94411
94412     } catch (std::out_of_range& e) {
94413       {
94414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94415       };
94416     } catch (std::exception& e) {
94417       {
94418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94419       };
94420     } catch (Dali::DaliException e) {
94421       {
94422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94423       };
94424     } catch (...) {
94425       {
94426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94427       };
94428     }
94429   }
94430
94431   jresult = (void *)result;
94432   return jresult;
94433 }
94434
94435
94436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
94437   void * jresult ;
94438   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94439   int arg2 ;
94440   std::pair< unsigned int,Dali::Actor > result;
94441
94442   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94443   arg2 = (int)jarg2;
94444   {
94445     try {
94446       try {
94447         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
94448       }
94449       catch(std::out_of_range &_e) {
94450         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94451         return 0;
94452       }
94453
94454     } catch (std::out_of_range& e) {
94455       {
94456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94457       };
94458     } catch (std::exception& e) {
94459       {
94460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94461       };
94462     } catch (Dali::DaliException e) {
94463       {
94464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94465       };
94466     } catch (...) {
94467       {
94468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94469       };
94470     }
94471   }
94472
94473   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
94474   return jresult;
94475 }
94476
94477
94478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
94479   void * jresult ;
94480   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94481   int arg2 ;
94482   std::pair< unsigned int,Dali::Actor > *result = 0 ;
94483
94484   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94485   arg2 = (int)jarg2;
94486   {
94487     try {
94488       try {
94489         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
94490       }
94491       catch(std::out_of_range &_e) {
94492         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94493         return 0;
94494       }
94495
94496     } catch (std::out_of_range& e) {
94497       {
94498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94499       };
94500     } catch (std::exception& e) {
94501       {
94502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94503       };
94504     } catch (Dali::DaliException e) {
94505       {
94506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94507       };
94508     } catch (...) {
94509       {
94510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94511       };
94512     }
94513   }
94514
94515   jresult = (void *)result;
94516   return jresult;
94517 }
94518
94519
94520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94521   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94522   int arg2 ;
94523   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94524
94525   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94526   arg2 = (int)jarg2;
94527   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94528   if (!arg3) {
94529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94530     return ;
94531   }
94532   {
94533     try {
94534       try {
94535         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);
94536       }
94537       catch(std::out_of_range &_e) {
94538         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94539         return ;
94540       }
94541
94542     } catch (std::out_of_range& e) {
94543       {
94544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94545       };
94546     } catch (std::exception& e) {
94547       {
94548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94549       };
94550     } catch (Dali::DaliException e) {
94551       {
94552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94553       };
94554     } catch (...) {
94555       {
94556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94557       };
94558     }
94559   }
94560
94561 }
94562
94563
94564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
94565   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94566   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
94567
94568   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94569   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
94570   if (!arg2) {
94571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94572     return ;
94573   }
94574   {
94575     try {
94576       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);
94577     } catch (std::out_of_range& e) {
94578       {
94579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94580       };
94581     } catch (std::exception& e) {
94582       {
94583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94584       };
94585     } catch (Dali::DaliException e) {
94586       {
94587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94588       };
94589     } catch (...) {
94590       {
94591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94592       };
94593     }
94594   }
94595
94596 }
94597
94598
94599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94600   void * jresult ;
94601   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94602   int arg2 ;
94603   int arg3 ;
94604   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94605
94606   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94607   arg2 = (int)jarg2;
94608   arg3 = (int)jarg3;
94609   {
94610     try {
94611       try {
94612         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);
94613       }
94614       catch(std::out_of_range &_e) {
94615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94616         return 0;
94617       }
94618       catch(std::invalid_argument &_e) {
94619         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94620         return 0;
94621       }
94622
94623     } catch (std::out_of_range& e) {
94624       {
94625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94626       };
94627     } catch (std::exception& e) {
94628       {
94629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94630       };
94631     } catch (Dali::DaliException e) {
94632       {
94633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94634       };
94635     } catch (...) {
94636       {
94637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94638       };
94639     }
94640   }
94641
94642   jresult = (void *)result;
94643   return jresult;
94644 }
94645
94646
94647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94648   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94649   int arg2 ;
94650   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
94651
94652   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94653   arg2 = (int)jarg2;
94654   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
94655   if (!arg3) {
94656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94657     return ;
94658   }
94659   {
94660     try {
94661       try {
94662         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);
94663       }
94664       catch(std::out_of_range &_e) {
94665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94666         return ;
94667       }
94668
94669     } catch (std::out_of_range& e) {
94670       {
94671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94672       };
94673     } catch (std::exception& e) {
94674       {
94675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94676       };
94677     } catch (Dali::DaliException e) {
94678       {
94679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94680       };
94681     } catch (...) {
94682       {
94683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94684       };
94685     }
94686   }
94687
94688 }
94689
94690
94691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94692   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94693   int arg2 ;
94694   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94695
94696   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94697   arg2 = (int)jarg2;
94698   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94699   if (!arg3) {
94700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94701     return ;
94702   }
94703   {
94704     try {
94705       try {
94706         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);
94707       }
94708       catch(std::out_of_range &_e) {
94709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94710         return ;
94711       }
94712
94713     } catch (std::out_of_range& e) {
94714       {
94715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94716       };
94717     } catch (std::exception& e) {
94718       {
94719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94720       };
94721     } catch (Dali::DaliException e) {
94722       {
94723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94724       };
94725     } catch (...) {
94726       {
94727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94728       };
94729     }
94730   }
94731
94732 }
94733
94734
94735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
94736   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94737   int arg2 ;
94738
94739   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94740   arg2 = (int)jarg2;
94741   {
94742     try {
94743       try {
94744         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
94745       }
94746       catch(std::out_of_range &_e) {
94747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94748         return ;
94749       }
94750
94751     } catch (std::out_of_range& e) {
94752       {
94753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94754       };
94755     } catch (std::exception& e) {
94756       {
94757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94758       };
94759     } catch (Dali::DaliException e) {
94760       {
94761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94762       };
94763     } catch (...) {
94764       {
94765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94766       };
94767     }
94768   }
94769
94770 }
94771
94772
94773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94774   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94775   int arg2 ;
94776   int arg3 ;
94777
94778   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94779   arg2 = (int)jarg2;
94780   arg3 = (int)jarg3;
94781   {
94782     try {
94783       try {
94784         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
94785       }
94786       catch(std::out_of_range &_e) {
94787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94788         return ;
94789       }
94790       catch(std::invalid_argument &_e) {
94791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94792         return ;
94793       }
94794
94795     } catch (std::out_of_range& e) {
94796       {
94797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94798       };
94799     } catch (std::exception& e) {
94800       {
94801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94802       };
94803     } catch (Dali::DaliException e) {
94804       {
94805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94806       };
94807     } catch (...) {
94808       {
94809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94810       };
94811     }
94812   }
94813
94814 }
94815
94816
94817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
94818   void * jresult ;
94819   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
94820   int arg2 ;
94821   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
94822
94823   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
94824   if (!arg1) {
94825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
94826     return 0;
94827   }
94828   arg2 = (int)jarg2;
94829   {
94830     try {
94831       try {
94832         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);
94833       }
94834       catch(std::out_of_range &_e) {
94835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94836         return 0;
94837       }
94838
94839     } catch (std::out_of_range& e) {
94840       {
94841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94842       };
94843     } catch (std::exception& e) {
94844       {
94845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94846       };
94847     } catch (Dali::DaliException e) {
94848       {
94849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94850       };
94851     } catch (...) {
94852       {
94853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94854       };
94855     }
94856   }
94857
94858   jresult = (void *)result;
94859   return jresult;
94860 }
94861
94862
94863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
94864   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94865
94866   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94867   {
94868     try {
94869       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94870     } catch (std::out_of_range& e) {
94871       {
94872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94873       };
94874     } catch (std::exception& e) {
94875       {
94876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94877       };
94878     } catch (Dali::DaliException e) {
94879       {
94880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94881       };
94882     } catch (...) {
94883       {
94884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94885       };
94886     }
94887   }
94888
94889 }
94890
94891
94892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94893   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94894   int arg2 ;
94895   int arg3 ;
94896
94897   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94898   arg2 = (int)jarg2;
94899   arg3 = (int)jarg3;
94900   {
94901     try {
94902       try {
94903         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94904       }
94905       catch(std::out_of_range &_e) {
94906         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94907         return ;
94908       }
94909       catch(std::invalid_argument &_e) {
94910         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94911         return ;
94912       }
94913
94914     } catch (std::out_of_range& e) {
94915       {
94916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94917       };
94918     } catch (std::exception& e) {
94919       {
94920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94921       };
94922     } catch (Dali::DaliException e) {
94923       {
94924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94925       };
94926     } catch (...) {
94927       {
94928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94929       };
94930     }
94931   }
94932
94933 }
94934
94935
94936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94937   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94938   int arg2 ;
94939   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94940
94941   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94942   arg2 = (int)jarg2;
94943   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94944   if (!arg3) {
94945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94946     return ;
94947   }
94948   {
94949     try {
94950       try {
94951         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);
94952       }
94953       catch(std::out_of_range &_e) {
94954         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94955         return ;
94956       }
94957
94958     } catch (std::out_of_range& e) {
94959       {
94960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94961       };
94962     } catch (std::exception& e) {
94963       {
94964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94965       };
94966     } catch (Dali::DaliException e) {
94967       {
94968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94969       };
94970     } catch (...) {
94971       {
94972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94973       };
94974     }
94975   }
94976
94977 }
94978
94979
94980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94981   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94982
94983   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94984   {
94985     try {
94986       delete arg1;
94987     } catch (std::out_of_range& e) {
94988       {
94989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94990       };
94991     } catch (std::exception& e) {
94992       {
94993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94994       };
94995     } catch (Dali::DaliException e) {
94996       {
94997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94998       };
94999     } catch (...) {
95000       {
95001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95002       };
95003     }
95004   }
95005
95006 }
95007
95008
95009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
95010   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95011
95012   arg1 = (std::vector< Dali::Actor > *)jarg1;
95013   {
95014     try {
95015       (arg1)->clear();
95016     } catch (std::out_of_range& e) {
95017       {
95018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95019       };
95020     } catch (std::exception& e) {
95021       {
95022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95023       };
95024     } catch (Dali::DaliException e) {
95025       {
95026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95027       };
95028     } catch (...) {
95029       {
95030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95031       };
95032     }
95033   }
95034
95035 }
95036
95037
95038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
95039   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95040   Dali::Actor *arg2 = 0 ;
95041
95042   arg1 = (std::vector< Dali::Actor > *)jarg1;
95043   arg2 = (Dali::Actor *)jarg2;
95044   if (!arg2) {
95045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95046     return ;
95047   }
95048   {
95049     try {
95050       (arg1)->push_back((Dali::Actor const &)*arg2);
95051     } catch (std::out_of_range& e) {
95052       {
95053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95054       };
95055     } catch (std::exception& e) {
95056       {
95057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95058       };
95059     } catch (Dali::DaliException e) {
95060       {
95061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95062       };
95063     } catch (...) {
95064       {
95065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95066       };
95067     }
95068   }
95069
95070 }
95071
95072
95073 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
95074   unsigned long jresult ;
95075   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95076   std::vector< Dali::Actor >::size_type result;
95077
95078   arg1 = (std::vector< Dali::Actor > *)jarg1;
95079   {
95080     try {
95081       result = ((std::vector< Dali::Actor > const *)arg1)->size();
95082     } catch (std::out_of_range& e) {
95083       {
95084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95085       };
95086     } catch (std::exception& e) {
95087       {
95088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95089       };
95090     } catch (Dali::DaliException e) {
95091       {
95092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95093       };
95094     } catch (...) {
95095       {
95096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95097       };
95098     }
95099   }
95100
95101   jresult = (unsigned long)result;
95102   return jresult;
95103 }
95104
95105
95106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
95107   unsigned long jresult ;
95108   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95109   std::vector< Dali::Actor >::size_type result;
95110
95111   arg1 = (std::vector< Dali::Actor > *)jarg1;
95112   {
95113     try {
95114       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
95115     } catch (std::out_of_range& e) {
95116       {
95117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95118       };
95119     } catch (std::exception& e) {
95120       {
95121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95122       };
95123     } catch (Dali::DaliException e) {
95124       {
95125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95126       };
95127     } catch (...) {
95128       {
95129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95130       };
95131     }
95132   }
95133
95134   jresult = (unsigned long)result;
95135   return jresult;
95136 }
95137
95138
95139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
95140   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95141   std::vector< Dali::Actor >::size_type arg2 ;
95142
95143   arg1 = (std::vector< Dali::Actor > *)jarg1;
95144   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
95145   {
95146     try {
95147       (arg1)->reserve(arg2);
95148     } catch (std::out_of_range& e) {
95149       {
95150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95151       };
95152     } catch (std::exception& e) {
95153       {
95154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95155       };
95156     } catch (Dali::DaliException e) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95159       };
95160     } catch (...) {
95161       {
95162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95163       };
95164     }
95165   }
95166
95167 }
95168
95169
95170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
95171   void * jresult ;
95172   std::vector< Dali::Actor > *result = 0 ;
95173
95174   {
95175     try {
95176       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
95177     } catch (std::out_of_range& e) {
95178       {
95179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95180       };
95181     } catch (std::exception& e) {
95182       {
95183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95184       };
95185     } catch (Dali::DaliException e) {
95186       {
95187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95188       };
95189     } catch (...) {
95190       {
95191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95192       };
95193     }
95194   }
95195
95196   jresult = (void *)result;
95197   return jresult;
95198 }
95199
95200
95201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
95202   void * jresult ;
95203   std::vector< Dali::Actor > *arg1 = 0 ;
95204   std::vector< Dali::Actor > *result = 0 ;
95205
95206   arg1 = (std::vector< Dali::Actor > *)jarg1;
95207   if (!arg1) {
95208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95209     return 0;
95210   }
95211   {
95212     try {
95213       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
95214     } catch (std::out_of_range& e) {
95215       {
95216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95217       };
95218     } catch (std::exception& e) {
95219       {
95220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95221       };
95222     } catch (Dali::DaliException e) {
95223       {
95224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95225       };
95226     } catch (...) {
95227       {
95228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95229       };
95230     }
95231   }
95232
95233   jresult = (void *)result;
95234   return jresult;
95235 }
95236
95237
95238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
95239   void * jresult ;
95240   int arg1 ;
95241   std::vector< Dali::Actor > *result = 0 ;
95242
95243   arg1 = (int)jarg1;
95244   {
95245     try {
95246       try {
95247         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
95248       }
95249       catch(std::out_of_range &_e) {
95250         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95251         return 0;
95252       }
95253
95254     } catch (std::out_of_range& e) {
95255       {
95256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95257       };
95258     } catch (std::exception& e) {
95259       {
95260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95261       };
95262     } catch (Dali::DaliException e) {
95263       {
95264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95265       };
95266     } catch (...) {
95267       {
95268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95269       };
95270     }
95271   }
95272
95273   jresult = (void *)result;
95274   return jresult;
95275 }
95276
95277
95278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
95279   void * jresult ;
95280   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95281   int arg2 ;
95282   Dali::Actor result;
95283
95284   arg1 = (std::vector< Dali::Actor > *)jarg1;
95285   arg2 = (int)jarg2;
95286   {
95287     try {
95288       try {
95289         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
95290       }
95291       catch(std::out_of_range &_e) {
95292         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95293         return 0;
95294       }
95295
95296     } catch (std::out_of_range& e) {
95297       {
95298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95299       };
95300     } catch (std::exception& e) {
95301       {
95302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95303       };
95304     } catch (Dali::DaliException e) {
95305       {
95306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95307       };
95308     } catch (...) {
95309       {
95310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95311       };
95312     }
95313   }
95314
95315   jresult = new Dali::Actor((const Dali::Actor &)result);
95316   return jresult;
95317 }
95318
95319
95320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
95321   void * jresult ;
95322   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95323   int arg2 ;
95324   Dali::Actor *result = 0 ;
95325
95326   arg1 = (std::vector< Dali::Actor > *)jarg1;
95327   arg2 = (int)jarg2;
95328   {
95329     try {
95330       try {
95331         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
95332       }
95333       catch(std::out_of_range &_e) {
95334         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95335         return 0;
95336       }
95337
95338     } catch (std::out_of_range& e) {
95339       {
95340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95341       };
95342     } catch (std::exception& e) {
95343       {
95344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95345       };
95346     } catch (Dali::DaliException e) {
95347       {
95348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95349       };
95350     } catch (...) {
95351       {
95352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95353       };
95354     }
95355   }
95356
95357   jresult = (void *)result;
95358   return jresult;
95359 }
95360
95361
95362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
95363   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95364   int arg2 ;
95365   Dali::Actor *arg3 = 0 ;
95366
95367   arg1 = (std::vector< Dali::Actor > *)jarg1;
95368   arg2 = (int)jarg2;
95369   arg3 = (Dali::Actor *)jarg3;
95370   if (!arg3) {
95371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95372     return ;
95373   }
95374   {
95375     try {
95376       try {
95377         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
95378       }
95379       catch(std::out_of_range &_e) {
95380         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95381         return ;
95382       }
95383
95384     } catch (std::out_of_range& e) {
95385       {
95386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95387       };
95388     } catch (std::exception& e) {
95389       {
95390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95391       };
95392     } catch (Dali::DaliException e) {
95393       {
95394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95395       };
95396     } catch (...) {
95397       {
95398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95399       };
95400     }
95401   }
95402
95403 }
95404
95405
95406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
95407   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95408   std::vector< Dali::Actor > *arg2 = 0 ;
95409
95410   arg1 = (std::vector< Dali::Actor > *)jarg1;
95411   arg2 = (std::vector< Dali::Actor > *)jarg2;
95412   if (!arg2) {
95413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95414     return ;
95415   }
95416   {
95417     try {
95418       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
95419     } catch (std::out_of_range& e) {
95420       {
95421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95422       };
95423     } catch (std::exception& e) {
95424       {
95425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95426       };
95427     } catch (Dali::DaliException e) {
95428       {
95429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95430       };
95431     } catch (...) {
95432       {
95433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95434       };
95435     }
95436   }
95437
95438 }
95439
95440
95441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
95442   void * jresult ;
95443   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95444   int arg2 ;
95445   int arg3 ;
95446   std::vector< Dali::Actor > *result = 0 ;
95447
95448   arg1 = (std::vector< Dali::Actor > *)jarg1;
95449   arg2 = (int)jarg2;
95450   arg3 = (int)jarg3;
95451   {
95452     try {
95453       try {
95454         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
95455       }
95456       catch(std::out_of_range &_e) {
95457         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95458         return 0;
95459       }
95460       catch(std::invalid_argument &_e) {
95461         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95462         return 0;
95463       }
95464
95465     } catch (std::out_of_range& e) {
95466       {
95467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95468       };
95469     } catch (std::exception& e) {
95470       {
95471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95472       };
95473     } catch (Dali::DaliException e) {
95474       {
95475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95476       };
95477     } catch (...) {
95478       {
95479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95480       };
95481     }
95482   }
95483
95484   jresult = (void *)result;
95485   return jresult;
95486 }
95487
95488
95489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
95490   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95491   int arg2 ;
95492   Dali::Actor *arg3 = 0 ;
95493
95494   arg1 = (std::vector< Dali::Actor > *)jarg1;
95495   arg2 = (int)jarg2;
95496   arg3 = (Dali::Actor *)jarg3;
95497   if (!arg3) {
95498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95499     return ;
95500   }
95501   {
95502     try {
95503       try {
95504         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
95505       }
95506       catch(std::out_of_range &_e) {
95507         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95508         return ;
95509       }
95510
95511     } catch (std::out_of_range& e) {
95512       {
95513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95514       };
95515     } catch (std::exception& e) {
95516       {
95517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95518       };
95519     } catch (Dali::DaliException e) {
95520       {
95521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95522       };
95523     } catch (...) {
95524       {
95525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95526       };
95527     }
95528   }
95529
95530 }
95531
95532
95533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
95534   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95535   int arg2 ;
95536   std::vector< Dali::Actor > *arg3 = 0 ;
95537
95538   arg1 = (std::vector< Dali::Actor > *)jarg1;
95539   arg2 = (int)jarg2;
95540   arg3 = (std::vector< Dali::Actor > *)jarg3;
95541   if (!arg3) {
95542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95543     return ;
95544   }
95545   {
95546     try {
95547       try {
95548         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95549       }
95550       catch(std::out_of_range &_e) {
95551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95552         return ;
95553       }
95554
95555     } catch (std::out_of_range& e) {
95556       {
95557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95558       };
95559     } catch (std::exception& e) {
95560       {
95561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95562       };
95563     } catch (Dali::DaliException e) {
95564       {
95565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95566       };
95567     } catch (...) {
95568       {
95569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95570       };
95571     }
95572   }
95573
95574 }
95575
95576
95577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
95578   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95579   int arg2 ;
95580
95581   arg1 = (std::vector< Dali::Actor > *)jarg1;
95582   arg2 = (int)jarg2;
95583   {
95584     try {
95585       try {
95586         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
95587       }
95588       catch(std::out_of_range &_e) {
95589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95590         return ;
95591       }
95592
95593     } catch (std::out_of_range& e) {
95594       {
95595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95596       };
95597     } catch (std::exception& e) {
95598       {
95599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95600       };
95601     } catch (Dali::DaliException e) {
95602       {
95603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95604       };
95605     } catch (...) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95608       };
95609     }
95610   }
95611
95612 }
95613
95614
95615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
95616   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95617   int arg2 ;
95618   int arg3 ;
95619
95620   arg1 = (std::vector< Dali::Actor > *)jarg1;
95621   arg2 = (int)jarg2;
95622   arg3 = (int)jarg3;
95623   {
95624     try {
95625       try {
95626         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
95627       }
95628       catch(std::out_of_range &_e) {
95629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95630         return ;
95631       }
95632       catch(std::invalid_argument &_e) {
95633         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95634         return ;
95635       }
95636
95637     } catch (std::out_of_range& e) {
95638       {
95639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95640       };
95641     } catch (std::exception& e) {
95642       {
95643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95644       };
95645     } catch (Dali::DaliException e) {
95646       {
95647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95648       };
95649     } catch (...) {
95650       {
95651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95652       };
95653     }
95654   }
95655
95656 }
95657
95658
95659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
95660   void * jresult ;
95661   Dali::Actor *arg1 = 0 ;
95662   int arg2 ;
95663   std::vector< Dali::Actor > *result = 0 ;
95664
95665   arg1 = (Dali::Actor *)jarg1;
95666   if (!arg1) {
95667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
95668     return 0;
95669   }
95670   arg2 = (int)jarg2;
95671   {
95672     try {
95673       try {
95674         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
95675       }
95676       catch(std::out_of_range &_e) {
95677         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95678         return 0;
95679       }
95680
95681     } catch (std::out_of_range& e) {
95682       {
95683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95684       };
95685     } catch (std::exception& e) {
95686       {
95687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95688       };
95689     } catch (Dali::DaliException e) {
95690       {
95691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95692       };
95693     } catch (...) {
95694       {
95695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95696       };
95697     }
95698   }
95699
95700   jresult = (void *)result;
95701   return jresult;
95702 }
95703
95704
95705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
95706   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95707
95708   arg1 = (std::vector< Dali::Actor > *)jarg1;
95709   {
95710     try {
95711       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
95712     } catch (std::out_of_range& e) {
95713       {
95714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95715       };
95716     } catch (std::exception& e) {
95717       {
95718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95719       };
95720     } catch (Dali::DaliException e) {
95721       {
95722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95723       };
95724     } catch (...) {
95725       {
95726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95727       };
95728     }
95729   }
95730
95731 }
95732
95733
95734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
95735   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95736   int arg2 ;
95737   int arg3 ;
95738
95739   arg1 = (std::vector< Dali::Actor > *)jarg1;
95740   arg2 = (int)jarg2;
95741   arg3 = (int)jarg3;
95742   {
95743     try {
95744       try {
95745         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
95746       }
95747       catch(std::out_of_range &_e) {
95748         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95749         return ;
95750       }
95751       catch(std::invalid_argument &_e) {
95752         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
95753         return ;
95754       }
95755
95756     } catch (std::out_of_range& e) {
95757       {
95758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95759       };
95760     } catch (std::exception& e) {
95761       {
95762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95763       };
95764     } catch (Dali::DaliException e) {
95765       {
95766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95767       };
95768     } catch (...) {
95769       {
95770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95771       };
95772     }
95773   }
95774
95775 }
95776
95777
95778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
95779   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95780   int arg2 ;
95781   std::vector< Dali::Actor > *arg3 = 0 ;
95782
95783   arg1 = (std::vector< Dali::Actor > *)jarg1;
95784   arg2 = (int)jarg2;
95785   arg3 = (std::vector< Dali::Actor > *)jarg3;
95786   if (!arg3) {
95787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
95788     return ;
95789   }
95790   {
95791     try {
95792       try {
95793         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
95794       }
95795       catch(std::out_of_range &_e) {
95796         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
95797         return ;
95798       }
95799
95800     } catch (std::out_of_range& e) {
95801       {
95802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95803       };
95804     } catch (std::exception& e) {
95805       {
95806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95807       };
95808     } catch (Dali::DaliException e) {
95809       {
95810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95811       };
95812     } catch (...) {
95813       {
95814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95815       };
95816     }
95817   }
95818
95819 }
95820
95821
95822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
95823   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
95824
95825   arg1 = (std::vector< Dali::Actor > *)jarg1;
95826   {
95827     try {
95828       delete arg1;
95829     } catch (std::out_of_range& e) {
95830       {
95831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95832       };
95833     } catch (std::exception& e) {
95834       {
95835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95836       };
95837     } catch (Dali::DaliException e) {
95838       {
95839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95840       };
95841     } catch (...) {
95842       {
95843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95844       };
95845     }
95846   }
95847
95848 }
95849
95850
95851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
95852   unsigned int jresult ;
95853   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95854   bool result;
95855
95856   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95857   {
95858     try {
95859       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95860     } catch (std::out_of_range& e) {
95861       {
95862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95863       };
95864     } catch (std::exception& e) {
95865       {
95866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95867       };
95868     } catch (Dali::DaliException e) {
95869       {
95870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95871       };
95872     } catch (...) {
95873       {
95874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95875       };
95876     }
95877   }
95878
95879   jresult = result;
95880   return jresult;
95881 }
95882
95883
95884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95885   unsigned long jresult ;
95886   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95887   std::size_t result;
95888
95889   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95890   {
95891     try {
95892       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95893     } catch (std::out_of_range& e) {
95894       {
95895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (std::exception& e) {
95898       {
95899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95900       };
95901     } catch (Dali::DaliException e) {
95902       {
95903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95904       };
95905     } catch (...) {
95906       {
95907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95908       };
95909     }
95910   }
95911
95912   jresult = (unsigned long)result;
95913   return jresult;
95914 }
95915
95916
95917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95918   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95919   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95920
95921   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95922   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95923   {
95924     try {
95925       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95926     } catch (std::out_of_range& e) {
95927       {
95928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95929       };
95930     } catch (std::exception& e) {
95931       {
95932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95933       };
95934     } catch (Dali::DaliException e) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95937       };
95938     } catch (...) {
95939       {
95940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95941       };
95942     }
95943   }
95944
95945 }
95946
95947
95948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95949   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95950   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95951
95952   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95953   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95954   {
95955     try {
95956       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95957     } catch (std::out_of_range& e) {
95958       {
95959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95960       };
95961     } catch (std::exception& e) {
95962       {
95963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95964       };
95965     } catch (Dali::DaliException e) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95968       };
95969     } catch (...) {
95970       {
95971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95972       };
95973     }
95974   }
95975
95976 }
95977
95978
95979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95980   unsigned int jresult ;
95981   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95982   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95983   bool result;
95984
95985   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95986   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95987   if (!arg2) {
95988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95989     return 0;
95990   }
95991   {
95992     try {
95993       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95994     } catch (std::out_of_range& e) {
95995       {
95996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95997       };
95998     } catch (std::exception& e) {
95999       {
96000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96001       };
96002     } catch (Dali::DaliException e) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96005       };
96006     } catch (...) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96009       };
96010     }
96011   }
96012
96013   jresult = result;
96014   return jresult;
96015 }
96016
96017
96018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
96019   void * jresult ;
96020   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
96021
96022   {
96023     try {
96024       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
96025     } catch (std::out_of_range& e) {
96026       {
96027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96028       };
96029     } catch (std::exception& e) {
96030       {
96031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96032       };
96033     } catch (Dali::DaliException e) {
96034       {
96035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96036       };
96037     } catch (...) {
96038       {
96039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96040       };
96041     }
96042   }
96043
96044   jresult = (void *)result;
96045   return jresult;
96046 }
96047
96048
96049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
96050   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
96051
96052   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
96053   {
96054     try {
96055       delete arg1;
96056     } catch (std::out_of_range& e) {
96057       {
96058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96059       };
96060     } catch (std::exception& e) {
96061       {
96062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96063       };
96064     } catch (Dali::DaliException e) {
96065       {
96066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96067       };
96068     } catch (...) {
96069       {
96070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96071       };
96072     }
96073   }
96074
96075 }
96076
96077
96078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
96079   unsigned int jresult ;
96080   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96081   bool result;
96082
96083   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96084   {
96085     try {
96086       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);
96087     } catch (std::out_of_range& e) {
96088       {
96089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96090       };
96091     } catch (std::exception& e) {
96092       {
96093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96094       };
96095     } catch (Dali::DaliException e) {
96096       {
96097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96098       };
96099     } catch (...) {
96100       {
96101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96102       };
96103     }
96104   }
96105
96106   jresult = result;
96107   return jresult;
96108 }
96109
96110
96111 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
96112   unsigned long jresult ;
96113   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96114   std::size_t result;
96115
96116   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96117   {
96118     try {
96119       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);
96120     } catch (std::out_of_range& e) {
96121       {
96122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96123       };
96124     } catch (std::exception& e) {
96125       {
96126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96127       };
96128     } catch (Dali::DaliException e) {
96129       {
96130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96131       };
96132     } catch (...) {
96133       {
96134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96135       };
96136     }
96137   }
96138
96139   jresult = (unsigned long)result;
96140   return jresult;
96141 }
96142
96143
96144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
96145   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96146   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96147
96148   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96149   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96150   {
96151     try {
96152       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
96153     } catch (std::out_of_range& e) {
96154       {
96155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96156       };
96157     } catch (std::exception& e) {
96158       {
96159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96160       };
96161     } catch (Dali::DaliException e) {
96162       {
96163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96164       };
96165     } catch (...) {
96166       {
96167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96168       };
96169     }
96170   }
96171
96172 }
96173
96174
96175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
96176   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96177   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
96178
96179   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96180   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
96181   {
96182     try {
96183       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
96184     } catch (std::out_of_range& e) {
96185       {
96186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96187       };
96188     } catch (std::exception& e) {
96189       {
96190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96191       };
96192     } catch (Dali::DaliException e) {
96193       {
96194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96195       };
96196     } catch (...) {
96197       {
96198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96199       };
96200     }
96201   }
96202
96203 }
96204
96205
96206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96207   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96208   Dali::Actor arg2 ;
96209   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
96210   Dali::Actor *argp2 ;
96211
96212   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96213   argp2 = (Dali::Actor *)jarg2;
96214   if (!argp2) {
96215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96216     return ;
96217   }
96218   arg2 = *argp2;
96219   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
96220   {
96221     try {
96222       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
96223     } catch (std::out_of_range& e) {
96224       {
96225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96226       };
96227     } catch (std::exception& e) {
96228       {
96229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96230       };
96231     } catch (Dali::DaliException e) {
96232       {
96233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96234       };
96235     } catch (...) {
96236       {
96237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96238       };
96239     }
96240   }
96241
96242 }
96243
96244
96245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
96246   void * jresult ;
96247   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
96248
96249   {
96250     try {
96251       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
96252     } catch (std::out_of_range& e) {
96253       {
96254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96255       };
96256     } catch (std::exception& e) {
96257       {
96258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96259       };
96260     } catch (Dali::DaliException e) {
96261       {
96262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96263       };
96264     } catch (...) {
96265       {
96266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96267       };
96268     }
96269   }
96270
96271   jresult = (void *)result;
96272   return jresult;
96273 }
96274
96275
96276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
96277   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
96278
96279   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
96280   {
96281     try {
96282       delete arg1;
96283     } catch (std::out_of_range& e) {
96284       {
96285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96286       };
96287     } catch (std::exception& e) {
96288       {
96289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96290       };
96291     } catch (Dali::DaliException e) {
96292       {
96293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96294       };
96295     } catch (...) {
96296       {
96297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96298       };
96299     }
96300   }
96301
96302 }
96303
96304
96305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
96306   unsigned int jresult ;
96307   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96308   bool result;
96309
96310   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96311   {
96312     try {
96313       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96314     } catch (std::out_of_range& e) {
96315       {
96316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96317       };
96318     } catch (std::exception& e) {
96319       {
96320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96321       };
96322     } catch (Dali::DaliException e) {
96323       {
96324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96325       };
96326     } catch (...) {
96327       {
96328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96329       };
96330     }
96331   }
96332
96333   jresult = result;
96334   return jresult;
96335 }
96336
96337
96338 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
96339   unsigned long jresult ;
96340   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96341   std::size_t result;
96342
96343   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96344   {
96345     try {
96346       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
96347     } catch (std::out_of_range& e) {
96348       {
96349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96350       };
96351     } catch (std::exception& e) {
96352       {
96353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96354       };
96355     } catch (Dali::DaliException e) {
96356       {
96357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96358       };
96359     } catch (...) {
96360       {
96361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96362       };
96363     }
96364   }
96365
96366   jresult = (unsigned long)result;
96367   return jresult;
96368 }
96369
96370
96371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
96372   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96373   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96374
96375   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96376   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96377   {
96378     try {
96379       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
96380     } catch (std::out_of_range& e) {
96381       {
96382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96383       };
96384     } catch (std::exception& e) {
96385       {
96386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96387       };
96388     } catch (Dali::DaliException e) {
96389       {
96390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96391       };
96392     } catch (...) {
96393       {
96394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96395       };
96396     }
96397   }
96398
96399 }
96400
96401
96402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96403   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96404   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
96405
96406   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96407   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
96408   {
96409     try {
96410       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
96411     } catch (std::out_of_range& e) {
96412       {
96413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96414       };
96415     } catch (std::exception& e) {
96416       {
96417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96418       };
96419     } catch (Dali::DaliException e) {
96420       {
96421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96422       };
96423     } catch (...) {
96424       {
96425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96426       };
96427     }
96428   }
96429
96430 }
96431
96432
96433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
96434   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96435   Dali::Actor arg2 ;
96436   Dali::Actor arg3 ;
96437   Dali::Actor *argp2 ;
96438   Dali::Actor *argp3 ;
96439
96440   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96441   argp2 = (Dali::Actor *)jarg2;
96442   if (!argp2) {
96443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96444     return ;
96445   }
96446   arg2 = *argp2;
96447   argp3 = (Dali::Actor *)jarg3;
96448   if (!argp3) {
96449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96450     return ;
96451   }
96452   arg3 = *argp3;
96453   {
96454     try {
96455       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
96456     } catch (std::out_of_range& e) {
96457       {
96458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96459       };
96460     } catch (std::exception& e) {
96461       {
96462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96463       };
96464     } catch (Dali::DaliException e) {
96465       {
96466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96467       };
96468     } catch (...) {
96469       {
96470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96471       };
96472     }
96473   }
96474
96475 }
96476
96477
96478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
96479   void * jresult ;
96480   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
96481
96482   {
96483     try {
96484       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
96485     } catch (std::out_of_range& e) {
96486       {
96487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96488       };
96489     } catch (std::exception& e) {
96490       {
96491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96492       };
96493     } catch (Dali::DaliException e) {
96494       {
96495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96496       };
96497     } catch (...) {
96498       {
96499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96500       };
96501     }
96502   }
96503
96504   jresult = (void *)result;
96505   return jresult;
96506 }
96507
96508
96509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
96510   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
96511
96512   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
96513   {
96514     try {
96515       delete arg1;
96516     } catch (std::out_of_range& e) {
96517       {
96518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96519       };
96520     } catch (std::exception& e) {
96521       {
96522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96523       };
96524     } catch (Dali::DaliException e) {
96525       {
96526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96527       };
96528     } catch (...) {
96529       {
96530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96531       };
96532     }
96533   }
96534
96535 }
96536
96537
96538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
96539   unsigned int jresult ;
96540   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96541   bool result;
96542
96543   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96544   {
96545     try {
96546       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96547     } catch (std::out_of_range& e) {
96548       {
96549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96550       };
96551     } catch (std::exception& e) {
96552       {
96553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96554       };
96555     } catch (Dali::DaliException e) {
96556       {
96557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96558       };
96559     } catch (...) {
96560       {
96561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96562       };
96563     }
96564   }
96565
96566   jresult = result;
96567   return jresult;
96568 }
96569
96570
96571 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
96572   unsigned long jresult ;
96573   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96574   std::size_t result;
96575
96576   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96577   {
96578     try {
96579       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
96580     } catch (std::out_of_range& e) {
96581       {
96582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96583       };
96584     } catch (std::exception& e) {
96585       {
96586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96587       };
96588     } catch (Dali::DaliException e) {
96589       {
96590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96591       };
96592     } catch (...) {
96593       {
96594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96595       };
96596     }
96597   }
96598
96599   jresult = (unsigned long)result;
96600   return jresult;
96601 }
96602
96603
96604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
96605   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96606   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96607
96608   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96609   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96610   {
96611     try {
96612       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
96613     } catch (std::out_of_range& e) {
96614       {
96615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96616       };
96617     } catch (std::exception& e) {
96618       {
96619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96620       };
96621     } catch (Dali::DaliException e) {
96622       {
96623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96624       };
96625     } catch (...) {
96626       {
96627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96628       };
96629     }
96630   }
96631
96632 }
96633
96634
96635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96636   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96637   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
96638
96639   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96640   arg2 = (void (*)(Dali::Actor,bool))jarg2;
96641   {
96642     try {
96643       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96644     } catch (std::out_of_range& e) {
96645       {
96646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96647       };
96648     } catch (std::exception& e) {
96649       {
96650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96651       };
96652     } catch (Dali::DaliException e) {
96653       {
96654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96655       };
96656     } catch (...) {
96657       {
96658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96659       };
96660     }
96661   }
96662
96663 }
96664
96665
96666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
96667   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96668   Dali::Actor arg2 ;
96669   bool arg3 ;
96670   Dali::Actor *argp2 ;
96671
96672   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96673   argp2 = (Dali::Actor *)jarg2;
96674   if (!argp2) {
96675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
96676     return ;
96677   }
96678   arg2 = *argp2;
96679   arg3 = jarg3 ? true : false;
96680   {
96681     try {
96682       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
96683     } catch (std::out_of_range& e) {
96684       {
96685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96686       };
96687     } catch (std::exception& e) {
96688       {
96689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96690       };
96691     } catch (Dali::DaliException e) {
96692       {
96693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96694       };
96695     } catch (...) {
96696       {
96697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96698       };
96699     }
96700   }
96701
96702 }
96703
96704
96705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
96706   void * jresult ;
96707   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
96708
96709   {
96710     try {
96711       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
96712     } catch (std::out_of_range& e) {
96713       {
96714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96715       };
96716     } catch (std::exception& e) {
96717       {
96718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96719       };
96720     } catch (Dali::DaliException e) {
96721       {
96722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96723       };
96724     } catch (...) {
96725       {
96726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96727       };
96728     }
96729   }
96730
96731   jresult = (void *)result;
96732   return jresult;
96733 }
96734
96735
96736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
96737   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
96738
96739   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
96740   {
96741     try {
96742       delete arg1;
96743     } catch (std::out_of_range& e) {
96744       {
96745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96746       };
96747     } catch (std::exception& e) {
96748       {
96749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96750       };
96751     } catch (Dali::DaliException e) {
96752       {
96753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96754       };
96755     } catch (...) {
96756       {
96757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96758       };
96759     }
96760   }
96761
96762 }
96763
96764
96765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
96766   unsigned int jresult ;
96767   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96768   bool result;
96769
96770   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96771   {
96772     try {
96773       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);
96774     } catch (std::out_of_range& e) {
96775       {
96776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96777       };
96778     } catch (std::exception& e) {
96779       {
96780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96781       };
96782     } catch (Dali::DaliException e) {
96783       {
96784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96785       };
96786     } catch (...) {
96787       {
96788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96789       };
96790     }
96791   }
96792
96793   jresult = result;
96794   return jresult;
96795 }
96796
96797
96798 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
96799   unsigned long jresult ;
96800   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96801   std::size_t result;
96802
96803   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96804   {
96805     try {
96806       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);
96807     } catch (std::out_of_range& e) {
96808       {
96809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96810       };
96811     } catch (std::exception& e) {
96812       {
96813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96814       };
96815     } catch (Dali::DaliException e) {
96816       {
96817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96818       };
96819     } catch (...) {
96820       {
96821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96822       };
96823     }
96824   }
96825
96826   jresult = (unsigned long)result;
96827   return jresult;
96828 }
96829
96830
96831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
96832   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96833   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96834
96835   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96836   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96837   {
96838     try {
96839       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
96840     } catch (std::out_of_range& e) {
96841       {
96842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96843       };
96844     } catch (std::exception& e) {
96845       {
96846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96847       };
96848     } catch (Dali::DaliException e) {
96849       {
96850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96851       };
96852     } catch (...) {
96853       {
96854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96855       };
96856     }
96857   }
96858
96859 }
96860
96861
96862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96863   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96864   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
96865
96866   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96867   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96868   {
96869     try {
96870       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96871     } catch (std::out_of_range& e) {
96872       {
96873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96874       };
96875     } catch (std::exception& e) {
96876       {
96877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96878       };
96879     } catch (Dali::DaliException e) {
96880       {
96881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96882       };
96883     } catch (...) {
96884       {
96885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96886       };
96887     }
96888   }
96889
96890 }
96891
96892
96893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96894   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96895   Dali::Toolkit::StyleManager arg2 ;
96896   Dali::StyleChange::Type arg3 ;
96897   Dali::Toolkit::StyleManager *argp2 ;
96898
96899   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96900   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96901   if (!argp2) {
96902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96903     return ;
96904   }
96905   arg2 = *argp2;
96906   arg3 = (Dali::StyleChange::Type)jarg3;
96907   {
96908     try {
96909       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96910     } catch (std::out_of_range& e) {
96911       {
96912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96913       };
96914     } catch (std::exception& e) {
96915       {
96916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96917       };
96918     } catch (Dali::DaliException e) {
96919       {
96920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96921       };
96922     } catch (...) {
96923       {
96924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96925       };
96926     }
96927   }
96928
96929 }
96930
96931
96932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96933   void * jresult ;
96934   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96935
96936   {
96937     try {
96938       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96939     } catch (std::out_of_range& e) {
96940       {
96941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96942       };
96943     } catch (std::exception& e) {
96944       {
96945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96946       };
96947     } catch (Dali::DaliException e) {
96948       {
96949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96950       };
96951     } catch (...) {
96952       {
96953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96954       };
96955     }
96956   }
96957
96958   jresult = (void *)result;
96959   return jresult;
96960 }
96961
96962
96963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96964   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96965
96966   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96967   {
96968     try {
96969       delete arg1;
96970     } catch (std::out_of_range& e) {
96971       {
96972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96973       };
96974     } catch (std::exception& e) {
96975       {
96976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96977       };
96978     } catch (Dali::DaliException e) {
96979       {
96980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96981       };
96982     } catch (...) {
96983       {
96984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96985       };
96986     }
96987   }
96988
96989 }
96990
96991
96992 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96993   unsigned int jresult ;
96994   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96995   bool result;
96996
96997   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96998   {
96999     try {
97000       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97001     } catch (std::out_of_range& e) {
97002       {
97003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97004       };
97005     } catch (std::exception& e) {
97006       {
97007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97008       };
97009     } catch (Dali::DaliException e) {
97010       {
97011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97012       };
97013     } catch (...) {
97014       {
97015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97016       };
97017     }
97018   }
97019
97020   jresult = result;
97021   return jresult;
97022 }
97023
97024
97025 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
97026   unsigned long jresult ;
97027   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97028   std::size_t result;
97029
97030   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97031   {
97032     try {
97033       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
97034     } catch (std::out_of_range& e) {
97035       {
97036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97037       };
97038     } catch (std::exception& e) {
97039       {
97040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97041       };
97042     } catch (Dali::DaliException e) {
97043       {
97044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97045       };
97046     } catch (...) {
97047       {
97048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97049       };
97050     }
97051   }
97052
97053   jresult = (unsigned long)result;
97054   return jresult;
97055 }
97056
97057
97058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
97059   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97060   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97061
97062   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97063   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97064   {
97065     try {
97066       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
97067     } catch (std::out_of_range& e) {
97068       {
97069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97070       };
97071     } catch (std::exception& e) {
97072       {
97073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97074       };
97075     } catch (Dali::DaliException e) {
97076       {
97077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97078       };
97079     } catch (...) {
97080       {
97081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97082       };
97083     }
97084   }
97085
97086 }
97087
97088
97089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
97090   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97091   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
97092
97093   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97094   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
97095   {
97096     try {
97097       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
97098     } catch (std::out_of_range& e) {
97099       {
97100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97101       };
97102     } catch (std::exception& e) {
97103       {
97104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97105       };
97106     } catch (Dali::DaliException e) {
97107       {
97108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97109       };
97110     } catch (...) {
97111       {
97112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97113       };
97114     }
97115   }
97116
97117 }
97118
97119
97120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
97121   unsigned int jresult ;
97122   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97123   Dali::Toolkit::Button arg2 ;
97124   Dali::Toolkit::Button *argp2 ;
97125   bool result;
97126
97127   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97128   argp2 = (Dali::Toolkit::Button *)jarg2;
97129   if (!argp2) {
97130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
97131     return 0;
97132   }
97133   arg2 = *argp2;
97134   {
97135     try {
97136       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
97137     } catch (std::out_of_range& e) {
97138       {
97139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97140       };
97141     } catch (std::exception& e) {
97142       {
97143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97144       };
97145     } catch (Dali::DaliException e) {
97146       {
97147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97148       };
97149     } catch (...) {
97150       {
97151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97152       };
97153     }
97154   }
97155
97156   jresult = result;
97157   return jresult;
97158 }
97159
97160
97161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
97162   void * jresult ;
97163   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
97164
97165   {
97166     try {
97167       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
97168     } catch (std::out_of_range& e) {
97169       {
97170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97171       };
97172     } catch (std::exception& e) {
97173       {
97174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97175       };
97176     } catch (Dali::DaliException e) {
97177       {
97178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97179       };
97180     } catch (...) {
97181       {
97182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97183       };
97184     }
97185   }
97186
97187   jresult = (void *)result;
97188   return jresult;
97189 }
97190
97191
97192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
97193   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
97194
97195   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
97196   {
97197     try {
97198       delete arg1;
97199     } catch (std::out_of_range& e) {
97200       {
97201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97202       };
97203     } catch (std::exception& e) {
97204       {
97205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97206       };
97207     } catch (Dali::DaliException e) {
97208       {
97209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97210       };
97211     } catch (...) {
97212       {
97213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97214       };
97215     }
97216   }
97217
97218 }
97219
97220
97221 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
97222   unsigned int jresult ;
97223   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97224   bool result;
97225
97226   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97227   {
97228     try {
97229       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97230     } catch (std::out_of_range& e) {
97231       {
97232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97233       };
97234     } catch (std::exception& e) {
97235       {
97236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97237       };
97238     } catch (Dali::DaliException e) {
97239       {
97240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97241       };
97242     } catch (...) {
97243       {
97244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97245       };
97246     }
97247   }
97248
97249   jresult = result;
97250   return jresult;
97251 }
97252
97253
97254 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
97255   unsigned long jresult ;
97256   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97257   std::size_t result;
97258
97259   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97260   {
97261     try {
97262       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
97263     } catch (std::out_of_range& e) {
97264       {
97265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97266       };
97267     } catch (std::exception& e) {
97268       {
97269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97270       };
97271     } catch (Dali::DaliException e) {
97272       {
97273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97274       };
97275     } catch (...) {
97276       {
97277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97278       };
97279     }
97280   }
97281
97282   jresult = (unsigned long)result;
97283   return jresult;
97284 }
97285
97286
97287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
97288   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97289   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97290
97291   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97292   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97293   {
97294     try {
97295       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
97296     } catch (std::out_of_range& e) {
97297       {
97298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97299       };
97300     } catch (std::exception& e) {
97301       {
97302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97303       };
97304     } catch (Dali::DaliException e) {
97305       {
97306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97307       };
97308     } catch (...) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97311       };
97312     }
97313   }
97314
97315 }
97316
97317
97318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
97319   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97320   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
97321
97322   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97323   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
97324   {
97325     try {
97326       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
97327     } catch (std::out_of_range& e) {
97328       {
97329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97330       };
97331     } catch (std::exception& e) {
97332       {
97333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97334       };
97335     } catch (Dali::DaliException e) {
97336       {
97337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97338       };
97339     } catch (...) {
97340       {
97341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97342       };
97343     }
97344   }
97345
97346 }
97347
97348
97349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
97350   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97351   Dali::Toolkit::GaussianBlurView arg2 ;
97352   Dali::Toolkit::GaussianBlurView *argp2 ;
97353
97354   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97355   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
97356   if (!argp2) {
97357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
97358     return ;
97359   }
97360   arg2 = *argp2;
97361   {
97362     try {
97363       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
97364     } catch (std::out_of_range& e) {
97365       {
97366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97367       };
97368     } catch (std::exception& e) {
97369       {
97370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97371       };
97372     } catch (Dali::DaliException e) {
97373       {
97374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97375       };
97376     } catch (...) {
97377       {
97378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97379       };
97380     }
97381   }
97382
97383 }
97384
97385
97386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
97387   void * jresult ;
97388   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
97389
97390   {
97391     try {
97392       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
97393     } catch (std::out_of_range& e) {
97394       {
97395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97396       };
97397     } catch (std::exception& e) {
97398       {
97399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97400       };
97401     } catch (Dali::DaliException e) {
97402       {
97403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97404       };
97405     } catch (...) {
97406       {
97407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97408       };
97409     }
97410   }
97411
97412   jresult = (void *)result;
97413   return jresult;
97414 }
97415
97416
97417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
97418   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
97419
97420   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
97421   {
97422     try {
97423       delete arg1;
97424     } catch (std::out_of_range& e) {
97425       {
97426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97427       };
97428     } catch (std::exception& e) {
97429       {
97430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97431       };
97432     } catch (Dali::DaliException e) {
97433       {
97434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97435       };
97436     } catch (...) {
97437       {
97438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97439       };
97440     }
97441   }
97442
97443 }
97444
97445
97446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
97447   unsigned int jresult ;
97448   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97449   bool result;
97450
97451   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97452   {
97453     try {
97454       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);
97455     } catch (std::out_of_range& e) {
97456       {
97457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97458       };
97459     } catch (std::exception& e) {
97460       {
97461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97462       };
97463     } catch (Dali::DaliException e) {
97464       {
97465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97466       };
97467     } catch (...) {
97468       {
97469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97470       };
97471     }
97472   }
97473
97474   jresult = result;
97475   return jresult;
97476 }
97477
97478
97479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
97480   unsigned long jresult ;
97481   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97482   std::size_t result;
97483
97484   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97485   {
97486     try {
97487       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);
97488     } catch (std::out_of_range& e) {
97489       {
97490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97491       };
97492     } catch (std::exception& e) {
97493       {
97494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97495       };
97496     } catch (Dali::DaliException e) {
97497       {
97498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97499       };
97500     } catch (...) {
97501       {
97502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97503       };
97504     }
97505   }
97506
97507   jresult = (unsigned long)result;
97508   return jresult;
97509 }
97510
97511
97512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
97513   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97514   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97515
97516   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97517   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97518   {
97519     try {
97520       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
97521     } catch (std::out_of_range& e) {
97522       {
97523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97524       };
97525     } catch (std::exception& e) {
97526       {
97527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97528       };
97529     } catch (Dali::DaliException e) {
97530       {
97531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97532       };
97533     } catch (...) {
97534       {
97535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97536       };
97537     }
97538   }
97539
97540 }
97541
97542
97543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
97544   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97545   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
97546
97547   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97548   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
97549   {
97550     try {
97551       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
97552     } catch (std::out_of_range& e) {
97553       {
97554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97555       };
97556     } catch (std::exception& e) {
97557       {
97558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97559       };
97560     } catch (Dali::DaliException e) {
97561       {
97562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97563       };
97564     } catch (...) {
97565       {
97566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97567       };
97568     }
97569   }
97570
97571 }
97572
97573
97574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
97575   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97576   Dali::Toolkit::PageTurnView arg2 ;
97577   unsigned int arg3 ;
97578   bool arg4 ;
97579   Dali::Toolkit::PageTurnView *argp2 ;
97580
97581   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97582   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97583   if (!argp2) {
97584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97585     return ;
97586   }
97587   arg2 = *argp2;
97588   arg3 = (unsigned int)jarg3;
97589   arg4 = jarg4 ? true : false;
97590   {
97591     try {
97592       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97593     } catch (std::out_of_range& e) {
97594       {
97595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97596       };
97597     } catch (std::exception& e) {
97598       {
97599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97600       };
97601     } catch (Dali::DaliException e) {
97602       {
97603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97604       };
97605     } catch (...) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97608       };
97609     }
97610   }
97611
97612 }
97613
97614
97615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
97616   void * jresult ;
97617   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
97618
97619   {
97620     try {
97621       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
97622     } catch (std::out_of_range& e) {
97623       {
97624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97625       };
97626     } catch (std::exception& e) {
97627       {
97628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97629       };
97630     } catch (Dali::DaliException e) {
97631       {
97632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97633       };
97634     } catch (...) {
97635       {
97636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97637       };
97638     }
97639   }
97640
97641   jresult = (void *)result;
97642   return jresult;
97643 }
97644
97645
97646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
97647   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
97648
97649   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
97650   {
97651     try {
97652       delete arg1;
97653     } catch (std::out_of_range& e) {
97654       {
97655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97656       };
97657     } catch (std::exception& e) {
97658       {
97659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97660       };
97661     } catch (Dali::DaliException e) {
97662       {
97663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97664       };
97665     } catch (...) {
97666       {
97667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97668       };
97669     }
97670   }
97671
97672 }
97673
97674
97675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
97676   unsigned int jresult ;
97677   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97678   bool result;
97679
97680   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97681   {
97682     try {
97683       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97684     } catch (std::out_of_range& e) {
97685       {
97686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97687       };
97688     } catch (std::exception& e) {
97689       {
97690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97691       };
97692     } catch (Dali::DaliException e) {
97693       {
97694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97695       };
97696     } catch (...) {
97697       {
97698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97699       };
97700     }
97701   }
97702
97703   jresult = result;
97704   return jresult;
97705 }
97706
97707
97708 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
97709   unsigned long jresult ;
97710   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97711   std::size_t result;
97712
97713   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97714   {
97715     try {
97716       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
97717     } catch (std::out_of_range& e) {
97718       {
97719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97720       };
97721     } catch (std::exception& e) {
97722       {
97723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97724       };
97725     } catch (Dali::DaliException e) {
97726       {
97727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97728       };
97729     } catch (...) {
97730       {
97731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97732       };
97733     }
97734   }
97735
97736   jresult = (unsigned long)result;
97737   return jresult;
97738 }
97739
97740
97741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
97742   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97743   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97744
97745   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97746   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97747   {
97748     try {
97749       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
97750     } catch (std::out_of_range& e) {
97751       {
97752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97753       };
97754     } catch (std::exception& e) {
97755       {
97756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97757       };
97758     } catch (Dali::DaliException e) {
97759       {
97760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97761       };
97762     } catch (...) {
97763       {
97764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97765       };
97766     }
97767   }
97768
97769 }
97770
97771
97772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
97773   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97774   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
97775
97776   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97777   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
97778   {
97779     try {
97780       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
97781     } catch (std::out_of_range& e) {
97782       {
97783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97784       };
97785     } catch (std::exception& e) {
97786       {
97787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97788       };
97789     } catch (Dali::DaliException e) {
97790       {
97791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97792       };
97793     } catch (...) {
97794       {
97795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97796       };
97797     }
97798   }
97799
97800 }
97801
97802
97803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
97804   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97805   Dali::Toolkit::PageTurnView arg2 ;
97806   Dali::Toolkit::PageTurnView *argp2 ;
97807
97808   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97809   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
97810   if (!argp2) {
97811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
97812     return ;
97813   }
97814   arg2 = *argp2;
97815   {
97816     try {
97817       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
97818     } catch (std::out_of_range& e) {
97819       {
97820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97821       };
97822     } catch (std::exception& e) {
97823       {
97824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97825       };
97826     } catch (Dali::DaliException e) {
97827       {
97828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97829       };
97830     } catch (...) {
97831       {
97832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97833       };
97834     }
97835   }
97836
97837 }
97838
97839
97840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
97841   void * jresult ;
97842   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
97843
97844   {
97845     try {
97846       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
97847     } catch (std::out_of_range& e) {
97848       {
97849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97850       };
97851     } catch (std::exception& e) {
97852       {
97853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97854       };
97855     } catch (Dali::DaliException e) {
97856       {
97857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97858       };
97859     } catch (...) {
97860       {
97861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97862       };
97863     }
97864   }
97865
97866   jresult = (void *)result;
97867   return jresult;
97868 }
97869
97870
97871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97872   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97873
97874   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97875   {
97876     try {
97877       delete arg1;
97878     } catch (std::out_of_range& e) {
97879       {
97880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97881       };
97882     } catch (std::exception& e) {
97883       {
97884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97885       };
97886     } catch (Dali::DaliException e) {
97887       {
97888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97889       };
97890     } catch (...) {
97891       {
97892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97893       };
97894     }
97895   }
97896
97897 }
97898
97899
97900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97901   unsigned int jresult ;
97902   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97903   bool result;
97904
97905   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97906   {
97907     try {
97908       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);
97909     } catch (std::out_of_range& e) {
97910       {
97911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97912       };
97913     } catch (std::exception& e) {
97914       {
97915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97916       };
97917     } catch (Dali::DaliException e) {
97918       {
97919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97920       };
97921     } catch (...) {
97922       {
97923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97924       };
97925     }
97926   }
97927
97928   jresult = result;
97929   return jresult;
97930 }
97931
97932
97933 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97934   unsigned long jresult ;
97935   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97936   std::size_t result;
97937
97938   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97939   {
97940     try {
97941       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);
97942     } catch (std::out_of_range& e) {
97943       {
97944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97945       };
97946     } catch (std::exception& e) {
97947       {
97948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97949       };
97950     } catch (Dali::DaliException e) {
97951       {
97952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97953       };
97954     } catch (...) {
97955       {
97956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97957       };
97958     }
97959   }
97960
97961   jresult = (unsigned long)result;
97962   return jresult;
97963 }
97964
97965
97966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97967   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97968   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97969
97970   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97971   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97972   {
97973     try {
97974       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97975     } catch (std::out_of_range& e) {
97976       {
97977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97978       };
97979     } catch (std::exception& e) {
97980       {
97981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97982       };
97983     } catch (Dali::DaliException e) {
97984       {
97985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97986       };
97987     } catch (...) {
97988       {
97989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97990       };
97991     }
97992   }
97993
97994 }
97995
97996
97997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97998   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97999   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
98000
98001   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98002   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
98003   {
98004     try {
98005       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98006     } catch (std::out_of_range& e) {
98007       {
98008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98009       };
98010     } catch (std::exception& e) {
98011       {
98012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98013       };
98014     } catch (Dali::DaliException e) {
98015       {
98016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98017       };
98018     } catch (...) {
98019       {
98020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98021       };
98022     }
98023   }
98024
98025 }
98026
98027
98028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
98029   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98030   Dali::Toolkit::ProgressBar arg2 ;
98031   float arg3 ;
98032   float arg4 ;
98033   Dali::Toolkit::ProgressBar *argp2 ;
98034
98035   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98036   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
98037   if (!argp2) {
98038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
98039     return ;
98040   }
98041   arg2 = *argp2;
98042   arg3 = (float)jarg3;
98043   arg4 = (float)jarg4;
98044   {
98045     try {
98046       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
98047     } catch (std::out_of_range& e) {
98048       {
98049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98050       };
98051     } catch (std::exception& e) {
98052       {
98053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98054       };
98055     } catch (Dali::DaliException e) {
98056       {
98057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98058       };
98059     } catch (...) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98062       };
98063     }
98064   }
98065
98066 }
98067
98068
98069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
98070   void * jresult ;
98071   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
98072
98073   {
98074     try {
98075       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
98076     } catch (std::out_of_range& e) {
98077       {
98078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98079       };
98080     } catch (std::exception& e) {
98081       {
98082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98083       };
98084     } catch (Dali::DaliException e) {
98085       {
98086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98087       };
98088     } catch (...) {
98089       {
98090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98091       };
98092     }
98093   }
98094
98095   jresult = (void *)result;
98096   return jresult;
98097 }
98098
98099
98100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
98101   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
98102
98103   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
98104   {
98105     try {
98106       delete arg1;
98107     } catch (std::out_of_range& e) {
98108       {
98109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98110       };
98111     } catch (std::exception& e) {
98112       {
98113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98114       };
98115     } catch (Dali::DaliException e) {
98116       {
98117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98118       };
98119     } catch (...) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98122       };
98123     }
98124   }
98125
98126 }
98127
98128
98129 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
98130   unsigned int jresult ;
98131   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98132   bool result;
98133
98134   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98135   {
98136     try {
98137       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);
98138     } catch (std::out_of_range& e) {
98139       {
98140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98141       };
98142     } catch (std::exception& e) {
98143       {
98144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98145       };
98146     } catch (Dali::DaliException e) {
98147       {
98148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98149       };
98150     } catch (...) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98153       };
98154     }
98155   }
98156
98157   jresult = result;
98158   return jresult;
98159 }
98160
98161
98162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
98163   unsigned long jresult ;
98164   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98165   std::size_t result;
98166
98167   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98168   {
98169     try {
98170       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);
98171     } catch (std::out_of_range& e) {
98172       {
98173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98174       };
98175     } catch (std::exception& e) {
98176       {
98177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98178       };
98179     } catch (Dali::DaliException e) {
98180       {
98181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98182       };
98183     } catch (...) {
98184       {
98185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98186       };
98187     }
98188   }
98189
98190   jresult = (unsigned long)result;
98191   return jresult;
98192 }
98193
98194
98195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
98196   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98197   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98198
98199   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98200   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98201   {
98202     try {
98203       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98204     } catch (std::out_of_range& e) {
98205       {
98206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98207       };
98208     } catch (std::exception& e) {
98209       {
98210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98211       };
98212     } catch (Dali::DaliException e) {
98213       {
98214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98215       };
98216     } catch (...) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98219       };
98220     }
98221   }
98222
98223 }
98224
98225
98226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
98227   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98228   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
98229
98230   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98231   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
98232   {
98233     try {
98234       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98235     } catch (std::out_of_range& e) {
98236       {
98237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98238       };
98239     } catch (std::exception& e) {
98240       {
98241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98242       };
98243     } catch (Dali::DaliException e) {
98244       {
98245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98246       };
98247     } catch (...) {
98248       {
98249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98250       };
98251     }
98252   }
98253
98254 }
98255
98256
98257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
98258   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98259   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
98260
98261   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98262   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
98263   if (!arg2) {
98264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
98265     return ;
98266   }
98267   {
98268     try {
98269       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
98270     } catch (std::out_of_range& e) {
98271       {
98272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98273       };
98274     } catch (std::exception& e) {
98275       {
98276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98277       };
98278     } catch (Dali::DaliException e) {
98279       {
98280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98281       };
98282     } catch (...) {
98283       {
98284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98285       };
98286     }
98287   }
98288
98289 }
98290
98291
98292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
98293   void * jresult ;
98294   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
98295
98296   {
98297     try {
98298       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
98299     } catch (std::out_of_range& e) {
98300       {
98301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98302       };
98303     } catch (std::exception& e) {
98304       {
98305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98306       };
98307     } catch (Dali::DaliException e) {
98308       {
98309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98310       };
98311     } catch (...) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98314       };
98315     }
98316   }
98317
98318   jresult = (void *)result;
98319   return jresult;
98320 }
98321
98322
98323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
98324   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
98325
98326   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
98327   {
98328     try {
98329       delete arg1;
98330     } catch (std::out_of_range& e) {
98331       {
98332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98333       };
98334     } catch (std::exception& e) {
98335       {
98336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98337       };
98338     } catch (Dali::DaliException e) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98341       };
98342     } catch (...) {
98343       {
98344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98345       };
98346     }
98347   }
98348
98349 }
98350
98351
98352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
98353   unsigned int jresult ;
98354   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98355   bool result;
98356
98357   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98358   {
98359     try {
98360       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98368       };
98369     } catch (Dali::DaliException e) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98376       };
98377     }
98378   }
98379
98380   jresult = result;
98381   return jresult;
98382 }
98383
98384
98385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
98386   unsigned long jresult ;
98387   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98388   std::size_t result;
98389
98390   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98391   {
98392     try {
98393       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
98394     } catch (std::out_of_range& e) {
98395       {
98396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98397       };
98398     } catch (std::exception& e) {
98399       {
98400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98401       };
98402     } catch (Dali::DaliException e) {
98403       {
98404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98405       };
98406     } catch (...) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98409       };
98410     }
98411   }
98412
98413   jresult = (unsigned long)result;
98414   return jresult;
98415 }
98416
98417
98418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
98419   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98420   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98421
98422   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98423   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98424   {
98425     try {
98426       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98427     } catch (std::out_of_range& e) {
98428       {
98429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98430       };
98431     } catch (std::exception& e) {
98432       {
98433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98434       };
98435     } catch (Dali::DaliException e) {
98436       {
98437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98438       };
98439     } catch (...) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98442       };
98443     }
98444   }
98445
98446 }
98447
98448
98449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
98450   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98451   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
98452
98453   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98454   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
98455   {
98456     try {
98457       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98458     } catch (std::out_of_range& e) {
98459       {
98460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98461       };
98462     } catch (std::exception& e) {
98463       {
98464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98465       };
98466     } catch (Dali::DaliException e) {
98467       {
98468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98469       };
98470     } catch (...) {
98471       {
98472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98473       };
98474     }
98475   }
98476
98477 }
98478
98479
98480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
98481   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98482   Dali::Vector2 *arg2 = 0 ;
98483
98484   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98485   arg2 = (Dali::Vector2 *)jarg2;
98486   if (!arg2) {
98487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
98488     return ;
98489   }
98490   {
98491     try {
98492       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
98493     } catch (std::out_of_range& e) {
98494       {
98495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98496       };
98497     } catch (std::exception& e) {
98498       {
98499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98500       };
98501     } catch (Dali::DaliException e) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98504       };
98505     } catch (...) {
98506       {
98507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98508       };
98509     }
98510   }
98511
98512 }
98513
98514
98515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
98516   void * jresult ;
98517   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
98518
98519   {
98520     try {
98521       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
98522     } catch (std::out_of_range& e) {
98523       {
98524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98525       };
98526     } catch (std::exception& e) {
98527       {
98528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98529       };
98530     } catch (Dali::DaliException e) {
98531       {
98532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98533       };
98534     } catch (...) {
98535       {
98536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98537       };
98538     }
98539   }
98540
98541   jresult = (void *)result;
98542   return jresult;
98543 }
98544
98545
98546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
98547   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
98548
98549   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
98550   {
98551     try {
98552       delete arg1;
98553     } catch (std::out_of_range& e) {
98554       {
98555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98556       };
98557     } catch (std::exception& e) {
98558       {
98559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98560       };
98561     } catch (Dali::DaliException e) {
98562       {
98563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98564       };
98565     } catch (...) {
98566       {
98567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98568       };
98569     }
98570   }
98571
98572 }
98573
98574
98575
98576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
98577   unsigned int jresult ;
98578   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98579   bool result;
98580
98581   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98582   {
98583     try {
98584       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);
98585     } catch (std::out_of_range& e) {
98586       {
98587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98588       };
98589     } catch (std::exception& e) {
98590       {
98591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98592       };
98593     } catch (Dali::DaliException e) {
98594       {
98595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98596       };
98597     } catch (...) {
98598       {
98599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98600       };
98601     }
98602   }
98603
98604   jresult = result;
98605   return jresult;
98606 }
98607
98608
98609 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
98610   unsigned long jresult ;
98611   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98612   std::size_t result;
98613
98614   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98615   {
98616     try {
98617       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);
98618     } catch (std::out_of_range& e) {
98619       {
98620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98621       };
98622     } catch (std::exception& e) {
98623       {
98624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98625       };
98626     } catch (Dali::DaliException e) {
98627       {
98628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98629       };
98630     } catch (...) {
98631       {
98632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98633       };
98634     }
98635   }
98636
98637   jresult = (unsigned long)result;
98638   return jresult;
98639 }
98640
98641
98642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
98643   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98644   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98645
98646   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98647   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98648   {
98649     try {
98650       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
98651     } catch (std::out_of_range& e) {
98652       {
98653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98654       };
98655     } catch (std::exception& e) {
98656       {
98657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98658       };
98659     } catch (Dali::DaliException e) {
98660       {
98661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98662       };
98663     } catch (...) {
98664       {
98665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98666       };
98667     }
98668   }
98669
98670 }
98671
98672
98673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
98674   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98675   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
98676
98677   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98678   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
98679   {
98680     try {
98681       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
98682     } catch (std::out_of_range& e) {
98683       {
98684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98685       };
98686     } catch (std::exception& e) {
98687       {
98688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98689       };
98690     } catch (Dali::DaliException e) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98693       };
98694     } catch (...) {
98695       {
98696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98697       };
98698     }
98699   }
98700
98701 }
98702
98703
98704 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
98705   unsigned int jresult ;
98706   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98707   Dali::Toolkit::Control arg2 ;
98708   Dali::KeyEvent *arg3 = 0 ;
98709   Dali::Toolkit::Control *argp2 ;
98710   bool result;
98711
98712   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98713   argp2 = (Dali::Toolkit::Control *)jarg2;
98714   if (!argp2) {
98715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98716     return 0;
98717   }
98718   arg2 = *argp2;
98719   arg3 = (Dali::KeyEvent *)jarg3;
98720   if (!arg3) {
98721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
98722     return 0;
98723   }
98724   {
98725     try {
98726       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);
98727     } catch (std::out_of_range& e) {
98728       {
98729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98730       };
98731     } catch (std::exception& e) {
98732       {
98733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98734       };
98735     } catch (Dali::DaliException e) {
98736       {
98737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98738       };
98739     } catch (...) {
98740       {
98741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98742       };
98743     }
98744   }
98745
98746   jresult = result;
98747   return jresult;
98748 }
98749
98750
98751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
98752   void * jresult ;
98753   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
98754
98755   {
98756     try {
98757       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
98758     } catch (std::out_of_range& e) {
98759       {
98760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98761       };
98762     } catch (std::exception& e) {
98763       {
98764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98765       };
98766     } catch (Dali::DaliException e) {
98767       {
98768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98769       };
98770     } catch (...) {
98771       {
98772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98773       };
98774     }
98775   }
98776
98777   jresult = (void *)result;
98778   return jresult;
98779 }
98780
98781
98782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
98783   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
98784
98785   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
98786   {
98787     try {
98788       delete arg1;
98789     } catch (std::out_of_range& e) {
98790       {
98791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98792       };
98793     } catch (std::exception& e) {
98794       {
98795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98796       };
98797     } catch (Dali::DaliException e) {
98798       {
98799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98800       };
98801     } catch (...) {
98802       {
98803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98804       };
98805     }
98806   }
98807
98808 }
98809
98810
98811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
98812   unsigned int jresult ;
98813   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98814   bool result;
98815
98816   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98817   {
98818     try {
98819       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98820     } catch (std::out_of_range& e) {
98821       {
98822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98823       };
98824     } catch (std::exception& e) {
98825       {
98826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98827       };
98828     } catch (Dali::DaliException e) {
98829       {
98830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98831       };
98832     } catch (...) {
98833       {
98834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98835       };
98836     }
98837   }
98838
98839   jresult = result;
98840   return jresult;
98841 }
98842
98843
98844 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
98845   unsigned long jresult ;
98846   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98847   std::size_t result;
98848
98849   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98850   {
98851     try {
98852       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98853     } catch (std::out_of_range& e) {
98854       {
98855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98856       };
98857     } catch (std::exception& e) {
98858       {
98859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98860       };
98861     } catch (Dali::DaliException e) {
98862       {
98863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98864       };
98865     } catch (...) {
98866       {
98867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98868       };
98869     }
98870   }
98871
98872   jresult = (unsigned long)result;
98873   return jresult;
98874 }
98875
98876
98877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98878   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98879   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98880
98881   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98882   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98883   {
98884     try {
98885       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98886     } catch (std::out_of_range& e) {
98887       {
98888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98889       };
98890     } catch (std::exception& e) {
98891       {
98892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98893       };
98894     } catch (Dali::DaliException e) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98897       };
98898     } catch (...) {
98899       {
98900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98901       };
98902     }
98903   }
98904
98905 }
98906
98907
98908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98909   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98910   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98911
98912   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98913   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98914   {
98915     try {
98916       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98917     } catch (std::out_of_range& e) {
98918       {
98919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98920       };
98921     } catch (std::exception& e) {
98922       {
98923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98924       };
98925     } catch (Dali::DaliException e) {
98926       {
98927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98928       };
98929     } catch (...) {
98930       {
98931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98932       };
98933     }
98934   }
98935
98936 }
98937
98938
98939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98940   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98941   Dali::Toolkit::Control arg2 ;
98942   Dali::Toolkit::Control *argp2 ;
98943
98944   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98945   argp2 = (Dali::Toolkit::Control *)jarg2;
98946   if (!argp2) {
98947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98948     return ;
98949   }
98950   arg2 = *argp2;
98951   {
98952     try {
98953       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98954     } catch (std::out_of_range& e) {
98955       {
98956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98957       };
98958     } catch (std::exception& e) {
98959       {
98960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98961       };
98962     } catch (Dali::DaliException e) {
98963       {
98964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98965       };
98966     } catch (...) {
98967       {
98968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98969       };
98970     }
98971   }
98972
98973 }
98974
98975
98976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98977   void * jresult ;
98978   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98979
98980   {
98981     try {
98982       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98983     } catch (std::out_of_range& e) {
98984       {
98985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98986       };
98987     } catch (std::exception& e) {
98988       {
98989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98990       };
98991     } catch (Dali::DaliException e) {
98992       {
98993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98994       };
98995     } catch (...) {
98996       {
98997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98998       };
98999     }
99000   }
99001
99002   jresult = (void *)result;
99003   return jresult;
99004 }
99005
99006
99007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
99008   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
99009
99010   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
99011   {
99012     try {
99013       delete arg1;
99014     } catch (std::out_of_range& e) {
99015       {
99016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99017       };
99018     } catch (std::exception& e) {
99019       {
99020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99021       };
99022     } catch (Dali::DaliException e) {
99023       {
99024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99025       };
99026     } catch (...) {
99027       {
99028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99029       };
99030     }
99031   }
99032
99033 }
99034
99035
99036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
99037   unsigned int jresult ;
99038   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99039   bool result;
99040
99041   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99042   {
99043     try {
99044       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99045     } catch (std::out_of_range& e) {
99046       {
99047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99048       };
99049     } catch (std::exception& e) {
99050       {
99051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99052       };
99053     } catch (Dali::DaliException e) {
99054       {
99055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99056       };
99057     } catch (...) {
99058       {
99059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99060       };
99061     }
99062   }
99063
99064   jresult = result;
99065   return jresult;
99066 }
99067
99068
99069 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
99070   unsigned long jresult ;
99071   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99072   std::size_t result;
99073
99074   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99075   {
99076     try {
99077       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
99078     } catch (std::out_of_range& e) {
99079       {
99080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99081       };
99082     } catch (std::exception& e) {
99083       {
99084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99085       };
99086     } catch (Dali::DaliException e) {
99087       {
99088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99089       };
99090     } catch (...) {
99091       {
99092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99093       };
99094     }
99095   }
99096
99097   jresult = (unsigned long)result;
99098   return jresult;
99099 }
99100
99101
99102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
99103   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99104   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99105
99106   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99107   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99108   {
99109     try {
99110       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
99111     } catch (std::out_of_range& e) {
99112       {
99113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99114       };
99115     } catch (std::exception& e) {
99116       {
99117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99118       };
99119     } catch (Dali::DaliException e) {
99120       {
99121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99122       };
99123     } catch (...) {
99124       {
99125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99126       };
99127     }
99128   }
99129
99130 }
99131
99132
99133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
99134   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99135   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
99136
99137   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99138   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
99139   {
99140     try {
99141       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
99142     } catch (std::out_of_range& e) {
99143       {
99144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99145       };
99146     } catch (std::exception& e) {
99147       {
99148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99149       };
99150     } catch (Dali::DaliException e) {
99151       {
99152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99153       };
99154     } catch (...) {
99155       {
99156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99157       };
99158     }
99159   }
99160
99161 }
99162
99163
99164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
99165   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99166   Dali::Toolkit::VideoView *arg2 = 0 ;
99167
99168   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99169   arg2 = (Dali::Toolkit::VideoView *)jarg2;
99170   if (!arg2) {
99171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
99172     return ;
99173   }
99174   {
99175     try {
99176       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
99177     } catch (std::out_of_range& e) {
99178       {
99179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99180       };
99181     } catch (std::exception& e) {
99182       {
99183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99184       };
99185     } catch (Dali::DaliException e) {
99186       {
99187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99188       };
99189     } catch (...) {
99190       {
99191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99192       };
99193     }
99194   }
99195
99196 }
99197
99198
99199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
99200   void * jresult ;
99201   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
99202
99203   {
99204     try {
99205       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
99206     } catch (std::out_of_range& e) {
99207       {
99208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99209       };
99210     } catch (std::exception& e) {
99211       {
99212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99213       };
99214     } catch (Dali::DaliException e) {
99215       {
99216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99217       };
99218     } catch (...) {
99219       {
99220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99221       };
99222     }
99223   }
99224
99225   jresult = (void *)result;
99226   return jresult;
99227 }
99228
99229
99230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
99231   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
99232
99233   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
99234   {
99235     try {
99236       delete arg1;
99237     } catch (std::out_of_range& e) {
99238       {
99239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99240       };
99241     } catch (std::exception& e) {
99242       {
99243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99244       };
99245     } catch (Dali::DaliException e) {
99246       {
99247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99248       };
99249     } catch (...) {
99250       {
99251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99252       };
99253     }
99254   }
99255
99256 }
99257
99258
99259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
99260   unsigned int jresult ;
99261   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99262   bool result;
99263
99264   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99265   {
99266     try {
99267       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99268     } catch (std::out_of_range& e) {
99269       {
99270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99271       };
99272     } catch (std::exception& e) {
99273       {
99274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99275       };
99276     } catch (Dali::DaliException e) {
99277       {
99278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99279       };
99280     } catch (...) {
99281       {
99282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99283       };
99284     }
99285   }
99286
99287   jresult = result;
99288   return jresult;
99289 }
99290
99291
99292 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
99293   unsigned long jresult ;
99294   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99295   std::size_t result;
99296
99297   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99298   {
99299     try {
99300       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
99301     } catch (std::out_of_range& e) {
99302       {
99303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99304       };
99305     } catch (std::exception& e) {
99306       {
99307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99308       };
99309     } catch (Dali::DaliException e) {
99310       {
99311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99312       };
99313     } catch (...) {
99314       {
99315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99316       };
99317     }
99318   }
99319
99320   jresult = (unsigned long)result;
99321   return jresult;
99322 }
99323
99324
99325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
99326   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99327   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99328
99329   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99330   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99331   {
99332     try {
99333       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
99334     } catch (std::out_of_range& e) {
99335       {
99336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99337       };
99338     } catch (std::exception& e) {
99339       {
99340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99341       };
99342     } catch (Dali::DaliException e) {
99343       {
99344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99345       };
99346     } catch (...) {
99347       {
99348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99349       };
99350     }
99351   }
99352
99353 }
99354
99355
99356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
99357   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99358   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
99359
99360   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99361   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
99362   {
99363     try {
99364       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
99365     } catch (std::out_of_range& e) {
99366       {
99367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99368       };
99369     } catch (std::exception& e) {
99370       {
99371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99372       };
99373     } catch (Dali::DaliException e) {
99374       {
99375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99376       };
99377     } catch (...) {
99378       {
99379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99380       };
99381     }
99382   }
99383
99384 }
99385
99386
99387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
99388   unsigned int jresult ;
99389   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99390   Dali::Toolkit::Slider arg2 ;
99391   float arg3 ;
99392   Dali::Toolkit::Slider *argp2 ;
99393   bool result;
99394
99395   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99396   argp2 = (Dali::Toolkit::Slider *)jarg2;
99397   if (!argp2) {
99398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99399     return 0;
99400   }
99401   arg2 = *argp2;
99402   arg3 = (float)jarg3;
99403   {
99404     try {
99405       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
99406     } catch (std::out_of_range& e) {
99407       {
99408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99409       };
99410     } catch (std::exception& e) {
99411       {
99412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99413       };
99414     } catch (Dali::DaliException e) {
99415       {
99416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99417       };
99418     } catch (...) {
99419       {
99420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99421       };
99422     }
99423   }
99424
99425   jresult = result;
99426   return jresult;
99427 }
99428
99429
99430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
99431   void * jresult ;
99432   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
99433
99434   {
99435     try {
99436       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
99437     } catch (std::out_of_range& e) {
99438       {
99439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99440       };
99441     } catch (std::exception& e) {
99442       {
99443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99444       };
99445     } catch (Dali::DaliException e) {
99446       {
99447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99448       };
99449     } catch (...) {
99450       {
99451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99452       };
99453     }
99454   }
99455
99456   jresult = (void *)result;
99457   return jresult;
99458 }
99459
99460
99461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
99462   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
99463
99464   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
99465   {
99466     try {
99467       delete arg1;
99468     } catch (std::out_of_range& e) {
99469       {
99470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99471       };
99472     } catch (std::exception& e) {
99473       {
99474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99475       };
99476     } catch (Dali::DaliException e) {
99477       {
99478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99479       };
99480     } catch (...) {
99481       {
99482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99483       };
99484     }
99485   }
99486
99487 }
99488
99489
99490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
99491   unsigned int jresult ;
99492   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99493   bool result;
99494
99495   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99496   {
99497     try {
99498       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99499     } catch (std::out_of_range& e) {
99500       {
99501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99502       };
99503     } catch (std::exception& e) {
99504       {
99505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99506       };
99507     } catch (Dali::DaliException e) {
99508       {
99509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99510       };
99511     } catch (...) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99514       };
99515     }
99516   }
99517
99518   jresult = result;
99519   return jresult;
99520 }
99521
99522
99523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
99524   unsigned long jresult ;
99525   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99526   std::size_t result;
99527
99528   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99529   {
99530     try {
99531       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
99532     } catch (std::out_of_range& e) {
99533       {
99534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99535       };
99536     } catch (std::exception& e) {
99537       {
99538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99539       };
99540     } catch (Dali::DaliException e) {
99541       {
99542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99543       };
99544     } catch (...) {
99545       {
99546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99547       };
99548     }
99549   }
99550
99551   jresult = (unsigned long)result;
99552   return jresult;
99553 }
99554
99555
99556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
99557   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99558   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99559
99560   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99561   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99562   {
99563     try {
99564       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
99565     } catch (std::out_of_range& e) {
99566       {
99567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99568       };
99569     } catch (std::exception& e) {
99570       {
99571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99572       };
99573     } catch (Dali::DaliException e) {
99574       {
99575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99576       };
99577     } catch (...) {
99578       {
99579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99580       };
99581     }
99582   }
99583
99584 }
99585
99586
99587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
99588   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99589   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
99590
99591   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99592   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
99593   {
99594     try {
99595       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
99596     } catch (std::out_of_range& e) {
99597       {
99598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99599       };
99600     } catch (std::exception& e) {
99601       {
99602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99603       };
99604     } catch (Dali::DaliException e) {
99605       {
99606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99607       };
99608     } catch (...) {
99609       {
99610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99611       };
99612     }
99613   }
99614
99615 }
99616
99617
99618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
99619   unsigned int jresult ;
99620   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99621   Dali::Toolkit::Slider arg2 ;
99622   int arg3 ;
99623   Dali::Toolkit::Slider *argp2 ;
99624   bool result;
99625
99626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99627   argp2 = (Dali::Toolkit::Slider *)jarg2;
99628   if (!argp2) {
99629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
99630     return 0;
99631   }
99632   arg2 = *argp2;
99633   arg3 = (int)jarg3;
99634   {
99635     try {
99636       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
99637     } catch (std::out_of_range& e) {
99638       {
99639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99640       };
99641     } catch (std::exception& e) {
99642       {
99643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99644       };
99645     } catch (Dali::DaliException e) {
99646       {
99647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99648       };
99649     } catch (...) {
99650       {
99651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99652       };
99653     }
99654   }
99655
99656   jresult = result;
99657   return jresult;
99658 }
99659
99660
99661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
99662   void * jresult ;
99663   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
99664
99665   {
99666     try {
99667       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
99668     } catch (std::out_of_range& e) {
99669       {
99670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99671       };
99672     } catch (std::exception& e) {
99673       {
99674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99675       };
99676     } catch (Dali::DaliException e) {
99677       {
99678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99679       };
99680     } catch (...) {
99681       {
99682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99683       };
99684     }
99685   }
99686
99687   jresult = (void *)result;
99688   return jresult;
99689 }
99690
99691
99692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
99693   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
99694
99695   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
99696   {
99697     try {
99698       delete arg1;
99699     } catch (std::out_of_range& e) {
99700       {
99701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99702       };
99703     } catch (std::exception& e) {
99704       {
99705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99706       };
99707     } catch (Dali::DaliException e) {
99708       {
99709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99710       };
99711     } catch (...) {
99712       {
99713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99714       };
99715     }
99716   }
99717
99718 }
99719
99720
99721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
99722   void * jresult ;
99723   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99724
99725   {
99726     try {
99727       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
99728     } catch (std::out_of_range& e) {
99729       {
99730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99731       };
99732     } catch (std::exception& e) {
99733       {
99734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99735       };
99736     } catch (Dali::DaliException e) {
99737       {
99738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99739       };
99740     } catch (...) {
99741       {
99742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99743       };
99744     }
99745   }
99746
99747   jresult = (void *)result;
99748   return jresult;
99749 }
99750
99751
99752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
99753   void * jresult ;
99754   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
99755   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99756
99757   arg1 = (Dali::Toolkit::Ruler *)jarg1;
99758   {
99759     try {
99760       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
99761     } catch (std::out_of_range& e) {
99762       {
99763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99764       };
99765     } catch (std::exception& e) {
99766       {
99767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99768       };
99769     } catch (Dali::DaliException e) {
99770       {
99771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99772       };
99773     } catch (...) {
99774       {
99775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99776       };
99777     }
99778   }
99779
99780   jresult = (void *)result;
99781   return jresult;
99782 }
99783
99784
99785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
99786   void * jresult ;
99787   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
99788   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99789
99790   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99791   if (!arg1) {
99792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99793     return 0;
99794   }
99795   {
99796     try {
99797       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
99798     } catch (std::out_of_range& e) {
99799       {
99800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99801       };
99802     } catch (std::exception& e) {
99803       {
99804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99805       };
99806     } catch (Dali::DaliException e) {
99807       {
99808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99809       };
99810     } catch (...) {
99811       {
99812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99813       };
99814     }
99815   }
99816
99817   jresult = (void *)result;
99818   return jresult;
99819 }
99820
99821
99822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
99823   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99824
99825   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99826   {
99827     try {
99828       delete arg1;
99829     } catch (std::out_of_range& e) {
99830       {
99831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99832       };
99833     } catch (std::exception& e) {
99834       {
99835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99836       };
99837     } catch (Dali::DaliException e) {
99838       {
99839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99840       };
99841     } catch (...) {
99842       {
99843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99844       };
99845     }
99846   }
99847
99848 }
99849
99850
99851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
99852   void * jresult ;
99853   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99854   Dali::Toolkit::Ruler *result = 0 ;
99855
99856   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99857   {
99858     try {
99859       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
99860     } catch (std::out_of_range& e) {
99861       {
99862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99863       };
99864     } catch (std::exception& e) {
99865       {
99866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99867       };
99868     } catch (Dali::DaliException e) {
99869       {
99870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99871       };
99872     } catch (...) {
99873       {
99874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99875       };
99876     }
99877   }
99878
99879   jresult = (void *)result;
99880   return jresult;
99881 }
99882
99883
99884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99885   void * jresult ;
99886   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99887   Dali::Toolkit::Ruler *result = 0 ;
99888
99889   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99890   {
99891     try {
99892       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99893     } catch (std::out_of_range& e) {
99894       {
99895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99896       };
99897     } catch (std::exception& e) {
99898       {
99899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99900       };
99901     } catch (Dali::DaliException e) {
99902       {
99903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99904       };
99905     } catch (...) {
99906       {
99907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99908       };
99909     }
99910   }
99911
99912   jresult = (void *)result;
99913   return jresult;
99914 }
99915
99916
99917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99918   void * jresult ;
99919   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99920   Dali::Toolkit::Ruler *result = 0 ;
99921
99922   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99923   {
99924     try {
99925       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99926     } catch (std::out_of_range& e) {
99927       {
99928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99929       };
99930     } catch (std::exception& e) {
99931       {
99932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99933       };
99934     } catch (Dali::DaliException e) {
99935       {
99936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99937       };
99938     } catch (...) {
99939       {
99940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99941       };
99942     }
99943   }
99944
99945   jresult = (void *)result;
99946   return jresult;
99947 }
99948
99949
99950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99951   void * jresult ;
99952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99953   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99954   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99955
99956   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99957   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99958   if (!arg2) {
99959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99960     return 0;
99961   }
99962   {
99963     try {
99964       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99965     } catch (std::out_of_range& e) {
99966       {
99967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99968       };
99969     } catch (std::exception& e) {
99970       {
99971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99972       };
99973     } catch (Dali::DaliException e) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99976       };
99977     } catch (...) {
99978       {
99979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99980       };
99981     }
99982   }
99983
99984   jresult = (void *)result;
99985   return jresult;
99986 }
99987
99988
99989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99990   void * jresult ;
99991   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99992   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99994
99995   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99996   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99997   {
99998     try {
99999       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
100000     } catch (std::out_of_range& e) {
100001       {
100002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100003       };
100004     } catch (std::exception& e) {
100005       {
100006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100007       };
100008     } catch (Dali::DaliException e) {
100009       {
100010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100011       };
100012     } catch (...) {
100013       {
100014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100015       };
100016     }
100017   }
100018
100019   jresult = (void *)result;
100020   return jresult;
100021 }
100022
100023
100024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
100025   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100026
100027   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100028   {
100029     try {
100030       (arg1)->Reset();
100031     } catch (std::out_of_range& e) {
100032       {
100033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100034       };
100035     } catch (std::exception& e) {
100036       {
100037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100038       };
100039     } catch (Dali::DaliException e) {
100040       {
100041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100042       };
100043     } catch (...) {
100044       {
100045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100046       };
100047     }
100048   }
100049
100050 }
100051
100052
100053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
100054   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100055   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
100056
100057   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100058   arg2 = (Dali::Toolkit::Ruler *)jarg2;
100059   {
100060     try {
100061       (arg1)->Reset(arg2);
100062     } catch (std::out_of_range& e) {
100063       {
100064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100065       };
100066     } catch (std::exception& e) {
100067       {
100068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100069       };
100070     } catch (Dali::DaliException e) {
100071       {
100072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100073       };
100074     } catch (...) {
100075       {
100076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100077       };
100078     }
100079   }
100080
100081 }
100082
100083
100084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
100085   void * jresult ;
100086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100087   Dali::Toolkit::Ruler *result = 0 ;
100088
100089   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100090   {
100091     try {
100092       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
100093     } catch (std::out_of_range& e) {
100094       {
100095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100096       };
100097     } catch (std::exception& e) {
100098       {
100099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100100       };
100101     } catch (Dali::DaliException e) {
100102       {
100103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100104       };
100105     } catch (...) {
100106       {
100107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100108       };
100109     }
100110   }
100111
100112   jresult = (void *)result;
100113   return jresult;
100114 }
100115
100116
100117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
100118   float jresult ;
100119   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100120   float arg2 ;
100121   float arg3 ;
100122   float result;
100123
100124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100125   arg2 = (float)jarg2;
100126   arg3 = (float)jarg3;
100127   {
100128     try {
100129       result = (float)(*arg1)->Snap(arg2,arg3);
100130     } catch (std::out_of_range& e) {
100131       {
100132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100133       };
100134     } catch (std::exception& e) {
100135       {
100136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100137       };
100138     } catch (Dali::DaliException e) {
100139       {
100140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100141       };
100142     } catch (...) {
100143       {
100144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100145       };
100146     }
100147   }
100148
100149   jresult = result;
100150   return jresult;
100151 }
100152
100153
100154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
100155   float jresult ;
100156   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100157   float arg2 ;
100158   float result;
100159
100160   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100161   arg2 = (float)jarg2;
100162   {
100163     try {
100164       result = (float)(*arg1)->Snap(arg2);
100165     } catch (std::out_of_range& e) {
100166       {
100167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100168       };
100169     } catch (std::exception& e) {
100170       {
100171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100172       };
100173     } catch (Dali::DaliException e) {
100174       {
100175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100176       };
100177     } catch (...) {
100178       {
100179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100180       };
100181     }
100182   }
100183
100184   jresult = result;
100185   return jresult;
100186 }
100187
100188
100189 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
100190   float jresult ;
100191   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100192   unsigned int arg2 ;
100193   unsigned int *arg3 = 0 ;
100194   bool arg4 ;
100195   float result;
100196
100197   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100198   arg2 = (unsigned int)jarg2;
100199   arg3 = (unsigned int *)jarg3;
100200   arg4 = jarg4 ? true : false;
100201   {
100202     try {
100203       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
100204     } catch (std::out_of_range& e) {
100205       {
100206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100207       };
100208     } catch (std::exception& e) {
100209       {
100210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100211       };
100212     } catch (Dali::DaliException e) {
100213       {
100214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100215       };
100216     } catch (...) {
100217       {
100218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100219       };
100220     }
100221   }
100222
100223   jresult = result;
100224   return jresult;
100225 }
100226
100227
100228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
100229   unsigned int jresult ;
100230   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100231   float arg2 ;
100232   bool arg3 ;
100233   unsigned int result;
100234
100235   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100236   arg2 = (float)jarg2;
100237   arg3 = jarg3 ? true : false;
100238   {
100239     try {
100240       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
100241     } catch (std::out_of_range& e) {
100242       {
100243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100244       };
100245     } catch (std::exception& e) {
100246       {
100247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100248       };
100249     } catch (Dali::DaliException e) {
100250       {
100251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100252       };
100253     } catch (...) {
100254       {
100255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100256       };
100257     }
100258   }
100259
100260   jresult = result;
100261   return jresult;
100262 }
100263
100264
100265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
100266   unsigned int jresult ;
100267   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100268   unsigned int result;
100269
100270   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100271   {
100272     try {
100273       result = (unsigned int)(*arg1)->GetTotalPages();
100274     } catch (std::out_of_range& e) {
100275       {
100276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100277       };
100278     } catch (std::exception& e) {
100279       {
100280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100281       };
100282     } catch (Dali::DaliException e) {
100283       {
100284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100285       };
100286     } catch (...) {
100287       {
100288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100289       };
100290     }
100291   }
100292
100293   jresult = result;
100294   return jresult;
100295 }
100296
100297
100298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
100299   int jresult ;
100300   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100301   Dali::Toolkit::Ruler::RulerType result;
100302
100303   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100304   {
100305     try {
100306       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
100307     } catch (std::out_of_range& e) {
100308       {
100309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100310       };
100311     } catch (std::exception& e) {
100312       {
100313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100314       };
100315     } catch (Dali::DaliException e) {
100316       {
100317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100318       };
100319     } catch (...) {
100320       {
100321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100322       };
100323     }
100324   }
100325
100326   jresult = (int)result;
100327   return jresult;
100328 }
100329
100330
100331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
100332   unsigned int jresult ;
100333   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100334   bool result;
100335
100336   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100337   {
100338     try {
100339       result = (bool)(*arg1)->IsEnabled();
100340     } catch (std::out_of_range& e) {
100341       {
100342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100343       };
100344     } catch (std::exception& e) {
100345       {
100346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100347       };
100348     } catch (Dali::DaliException e) {
100349       {
100350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100351       };
100352     } catch (...) {
100353       {
100354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100355       };
100356     }
100357   }
100358
100359   jresult = result;
100360   return jresult;
100361 }
100362
100363
100364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
100365   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100366
100367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100368   {
100369     try {
100370       (*arg1)->Enable();
100371     } catch (std::out_of_range& e) {
100372       {
100373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100374       };
100375     } catch (std::exception& e) {
100376       {
100377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100378       };
100379     } catch (Dali::DaliException e) {
100380       {
100381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100382       };
100383     } catch (...) {
100384       {
100385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100386       };
100387     }
100388   }
100389
100390 }
100391
100392
100393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
100394   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100395
100396   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100397   {
100398     try {
100399       (*arg1)->Disable();
100400     } catch (std::out_of_range& e) {
100401       {
100402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100403       };
100404     } catch (std::exception& e) {
100405       {
100406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100407       };
100408     } catch (Dali::DaliException e) {
100409       {
100410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100411       };
100412     } catch (...) {
100413       {
100414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100415       };
100416     }
100417   }
100418
100419 }
100420
100421
100422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
100423   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100424   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
100425   Dali::Toolkit::RulerDomain *argp2 ;
100426
100427   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100428   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
100429   if (!argp2) {
100430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
100431     return ;
100432   }
100433   arg2 = *argp2;
100434   {
100435     try {
100436       (*arg1)->SetDomain(arg2);
100437     } catch (std::out_of_range& e) {
100438       {
100439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100440       };
100441     } catch (std::exception& e) {
100442       {
100443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100444       };
100445     } catch (Dali::DaliException e) {
100446       {
100447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100448       };
100449     } catch (...) {
100450       {
100451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100452       };
100453     }
100454   }
100455
100456 }
100457
100458
100459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
100460   void * jresult ;
100461   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100462   Dali::Toolkit::RulerDomain *result = 0 ;
100463
100464   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100465   {
100466     try {
100467       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
100468     } catch (std::out_of_range& e) {
100469       {
100470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100471       };
100472     } catch (std::exception& e) {
100473       {
100474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100475       };
100476     } catch (Dali::DaliException e) {
100477       {
100478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100479       };
100480     } catch (...) {
100481       {
100482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100483       };
100484     }
100485   }
100486
100487   jresult = (void *)result;
100488   return jresult;
100489 }
100490
100491
100492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
100493   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100494
100495   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100496   {
100497     try {
100498       (*arg1)->DisableDomain();
100499     } catch (std::out_of_range& e) {
100500       {
100501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100502       };
100503     } catch (std::exception& e) {
100504       {
100505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100506       };
100507     } catch (Dali::DaliException e) {
100508       {
100509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100510       };
100511     } catch (...) {
100512       {
100513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100514       };
100515     }
100516   }
100517
100518 }
100519
100520
100521 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
100522   float jresult ;
100523   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100524   float arg2 ;
100525   float arg3 ;
100526   float arg4 ;
100527   float result;
100528
100529   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100530   arg2 = (float)jarg2;
100531   arg3 = (float)jarg3;
100532   arg4 = (float)jarg4;
100533   {
100534     try {
100535       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
100536     } catch (std::out_of_range& e) {
100537       {
100538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100539       };
100540     } catch (std::exception& e) {
100541       {
100542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100543       };
100544     } catch (Dali::DaliException e) {
100545       {
100546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100547       };
100548     } catch (...) {
100549       {
100550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100551       };
100552     }
100553   }
100554
100555   jresult = result;
100556   return jresult;
100557 }
100558
100559
100560 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
100561   float jresult ;
100562   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100563   float arg2 ;
100564   float arg3 ;
100565   float result;
100566
100567   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100568   arg2 = (float)jarg2;
100569   arg3 = (float)jarg3;
100570   {
100571     try {
100572       result = (float)(*arg1)->Clamp(arg2,arg3);
100573     } catch (std::out_of_range& e) {
100574       {
100575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100576       };
100577     } catch (std::exception& e) {
100578       {
100579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100580       };
100581     } catch (Dali::DaliException e) {
100582       {
100583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100584       };
100585     } catch (...) {
100586       {
100587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100588       };
100589     }
100590   }
100591
100592   jresult = result;
100593   return jresult;
100594 }
100595
100596
100597 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
100598   float jresult ;
100599   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100600   float arg2 ;
100601   float result;
100602
100603   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100604   arg2 = (float)jarg2;
100605   {
100606     try {
100607       result = (float)(*arg1)->Clamp(arg2);
100608     } catch (std::out_of_range& e) {
100609       {
100610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100611       };
100612     } catch (std::exception& e) {
100613       {
100614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100615       };
100616     } catch (Dali::DaliException e) {
100617       {
100618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100619       };
100620     } catch (...) {
100621       {
100622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100623       };
100624     }
100625   }
100626
100627   jresult = result;
100628   return jresult;
100629 }
100630
100631
100632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
100633   float jresult ;
100634   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100635   float arg2 ;
100636   float arg3 ;
100637   float arg4 ;
100638   Dali::Toolkit::ClampState *arg5 = 0 ;
100639   float result;
100640
100641   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100642   arg2 = (float)jarg2;
100643   arg3 = (float)jarg3;
100644   arg4 = (float)jarg4;
100645   arg5 = (Dali::Toolkit::ClampState *)jarg5;
100646   if (!arg5) {
100647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100648     return 0;
100649   }
100650   {
100651     try {
100652       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
100653     } catch (std::out_of_range& e) {
100654       {
100655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100656       };
100657     } catch (std::exception& e) {
100658       {
100659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100660       };
100661     } catch (Dali::DaliException e) {
100662       {
100663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100664       };
100665     } catch (...) {
100666       {
100667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100668       };
100669     }
100670   }
100671
100672   jresult = result;
100673   return jresult;
100674 }
100675
100676
100677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
100678   float jresult ;
100679   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100680   float arg2 ;
100681   float arg3 ;
100682   float arg4 ;
100683   float arg5 ;
100684   float result;
100685
100686   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100687   arg2 = (float)jarg2;
100688   arg3 = (float)jarg3;
100689   arg4 = (float)jarg4;
100690   arg5 = (float)jarg5;
100691   {
100692     try {
100693       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
100694     } catch (std::out_of_range& e) {
100695       {
100696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100697       };
100698     } catch (std::exception& e) {
100699       {
100700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100701       };
100702     } catch (Dali::DaliException e) {
100703       {
100704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100705       };
100706     } catch (...) {
100707       {
100708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100709       };
100710     }
100711   }
100712
100713   jresult = result;
100714   return jresult;
100715 }
100716
100717
100718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
100719   float jresult ;
100720   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100721   float arg2 ;
100722   float arg3 ;
100723   float arg4 ;
100724   float result;
100725
100726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100727   arg2 = (float)jarg2;
100728   arg3 = (float)jarg3;
100729   arg4 = (float)jarg4;
100730   {
100731     try {
100732       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
100733     } catch (std::out_of_range& e) {
100734       {
100735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100736       };
100737     } catch (std::exception& e) {
100738       {
100739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100740       };
100741     } catch (Dali::DaliException e) {
100742       {
100743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100744       };
100745     } catch (...) {
100746       {
100747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100748       };
100749     }
100750   }
100751
100752   jresult = result;
100753   return jresult;
100754 }
100755
100756
100757 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
100758   float jresult ;
100759   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100760   float arg2 ;
100761   float arg3 ;
100762   float result;
100763
100764   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100765   arg2 = (float)jarg2;
100766   arg3 = (float)jarg3;
100767   {
100768     try {
100769       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
100770     } catch (std::out_of_range& e) {
100771       {
100772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100773       };
100774     } catch (std::exception& e) {
100775       {
100776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100777       };
100778     } catch (Dali::DaliException e) {
100779       {
100780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100781       };
100782     } catch (...) {
100783       {
100784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100785       };
100786     }
100787   }
100788
100789   jresult = result;
100790   return jresult;
100791 }
100792
100793
100794 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
100795   float jresult ;
100796   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100797   float arg2 ;
100798   float result;
100799
100800   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100801   arg2 = (float)jarg2;
100802   {
100803     try {
100804       result = (float)(*arg1)->SnapAndClamp(arg2);
100805     } catch (std::out_of_range& e) {
100806       {
100807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100808       };
100809     } catch (std::exception& e) {
100810       {
100811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100812       };
100813     } catch (Dali::DaliException e) {
100814       {
100815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100816       };
100817     } catch (...) {
100818       {
100819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100820       };
100821     }
100822   }
100823
100824   jresult = result;
100825   return jresult;
100826 }
100827
100828
100829 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
100830   float jresult ;
100831   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100832   float arg2 ;
100833   float arg3 ;
100834   float arg4 ;
100835   float arg5 ;
100836   Dali::Toolkit::ClampState *arg6 = 0 ;
100837   float result;
100838
100839   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100840   arg2 = (float)jarg2;
100841   arg3 = (float)jarg3;
100842   arg4 = (float)jarg4;
100843   arg5 = (float)jarg5;
100844   arg6 = (Dali::Toolkit::ClampState *)jarg6;
100845   if (!arg6) {
100846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
100847     return 0;
100848   }
100849   {
100850     try {
100851       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
100852     } catch (std::out_of_range& e) {
100853       {
100854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100855       };
100856     } catch (std::exception& e) {
100857       {
100858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100859       };
100860     } catch (Dali::DaliException e) {
100861       {
100862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100863       };
100864     } catch (...) {
100865       {
100866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100867       };
100868     }
100869   }
100870
100871   jresult = result;
100872   return jresult;
100873 }
100874
100875
100876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100877   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100878
100879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100880   {
100881     try {
100882       (*arg1)->Reference();
100883     } catch (std::out_of_range& e) {
100884       {
100885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100886       };
100887     } catch (std::exception& e) {
100888       {
100889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100890       };
100891     } catch (Dali::DaliException e) {
100892       {
100893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100894       };
100895     } catch (...) {
100896       {
100897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100898       };
100899     }
100900   }
100901
100902 }
100903
100904
100905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100906   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100907
100908   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100909   {
100910     try {
100911       (*arg1)->Unreference();
100912     } catch (std::out_of_range& e) {
100913       {
100914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100915       };
100916     } catch (std::exception& e) {
100917       {
100918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100919       };
100920     } catch (Dali::DaliException e) {
100921       {
100922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100923       };
100924     } catch (...) {
100925       {
100926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100927       };
100928     }
100929   }
100930
100931 }
100932
100933
100934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100935   int jresult ;
100936   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100937   int result;
100938
100939   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100940   {
100941     try {
100942       result = (int)(*arg1)->ReferenceCount();
100943     } catch (std::out_of_range& e) {
100944       {
100945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100946       };
100947     } catch (std::exception& e) {
100948       {
100949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100950       };
100951     } catch (Dali::DaliException e) {
100952       {
100953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100954       };
100955     } catch (...) {
100956       {
100957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100958       };
100959     }
100960   }
100961
100962   jresult = result;
100963   return jresult;
100964 }
100965
100966
100967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100968   unsigned int jresult ;
100969   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100970   bool result;
100971
100972   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100973   {
100974     try {
100975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100976     } catch (std::out_of_range& e) {
100977       {
100978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100979       };
100980     } catch (std::exception& e) {
100981       {
100982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100983       };
100984     } catch (Dali::DaliException e) {
100985       {
100986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100987       };
100988     } catch (...) {
100989       {
100990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100991       };
100992     }
100993   }
100994
100995   jresult = result;
100996   return jresult;
100997 }
100998
100999
101000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
101001   unsigned long jresult ;
101002   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101003   std::size_t result;
101004
101005   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101006   {
101007     try {
101008       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
101009     } catch (std::out_of_range& e) {
101010       {
101011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101012       };
101013     } catch (std::exception& e) {
101014       {
101015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101016       };
101017     } catch (Dali::DaliException e) {
101018       {
101019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101020       };
101021     } catch (...) {
101022       {
101023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101024       };
101025     }
101026   }
101027
101028   jresult = (unsigned long)result;
101029   return jresult;
101030 }
101031
101032
101033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
101034   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101035   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101036
101037   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101038   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101039   {
101040     try {
101041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
101042     } catch (std::out_of_range& e) {
101043       {
101044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101045       };
101046     } catch (std::exception& e) {
101047       {
101048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101049       };
101050     } catch (Dali::DaliException e) {
101051       {
101052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101053       };
101054     } catch (...) {
101055       {
101056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101057       };
101058     }
101059   }
101060
101061 }
101062
101063
101064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
101065   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101066   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
101067
101068   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101069   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
101070   {
101071     try {
101072       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
101073     } catch (std::out_of_range& e) {
101074       {
101075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101076       };
101077     } catch (std::exception& e) {
101078       {
101079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101080       };
101081     } catch (Dali::DaliException e) {
101082       {
101083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101084       };
101085     } catch (...) {
101086       {
101087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101088       };
101089     }
101090   }
101091
101092 }
101093
101094
101095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
101096   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101097   Dali::Toolkit::Control arg2 ;
101098   Dali::Toolkit::Control *argp2 ;
101099
101100   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101101   argp2 = (Dali::Toolkit::Control *)jarg2;
101102   if (!argp2) {
101103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
101104     return ;
101105   }
101106   arg2 = *argp2;
101107   {
101108     try {
101109       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
101110     } catch (std::out_of_range& e) {
101111       {
101112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101113       };
101114     } catch (std::exception& e) {
101115       {
101116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101117       };
101118     } catch (Dali::DaliException e) {
101119       {
101120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101121       };
101122     } catch (...) {
101123       {
101124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101125       };
101126     }
101127   }
101128
101129 }
101130
101131
101132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
101133   void * jresult ;
101134   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
101135
101136   {
101137     try {
101138       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
101139     } catch (std::out_of_range& e) {
101140       {
101141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101142       };
101143     } catch (std::exception& e) {
101144       {
101145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101146       };
101147     } catch (Dali::DaliException e) {
101148       {
101149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101150       };
101151     } catch (...) {
101152       {
101153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101154       };
101155     }
101156   }
101157
101158   jresult = (void *)result;
101159   return jresult;
101160 }
101161
101162
101163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
101164   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
101165
101166   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
101167   {
101168     try {
101169       delete arg1;
101170     } catch (std::out_of_range& e) {
101171       {
101172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101173       };
101174     } catch (std::exception& e) {
101175       {
101176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101177       };
101178     } catch (Dali::DaliException e) {
101179       {
101180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101181       };
101182     } catch (...) {
101183       {
101184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101185       };
101186     }
101187   }
101188
101189 }
101190
101191 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
101192   Dali::RefObject *result = NULL;
101193
101194   if (arg1)
101195   {
101196     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
101197   }
101198   return result;
101199 }
101200
101201 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
101202     return (Dali::RefObject *)jarg1;
101203 }
101204
101205 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
101206     return (Dali::SignalObserver *)jarg1;
101207 }
101208
101209 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
101210     return (Dali::ConnectionTrackerInterface *)jarg1;
101211 }
101212
101213 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
101214     return (Dali::BaseHandle *)jarg1;
101215 }
101216
101217 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
101218     return (Dali::BaseHandle *)jarg1;
101219 }
101220
101221 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
101222     return (Dali::BaseHandle *)jarg1;
101223 }
101224
101225 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
101226     return (Dali::BaseHandle *)jarg1;
101227 }
101228
101229 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
101230     return (Dali::BaseHandle *)jarg1;
101231 }
101232
101233 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
101234     return (Dali::BaseHandle *)jarg1;
101235 }
101236
101237 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
101238     return (Dali::BaseHandle *)jarg1;
101239 }
101240
101241 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
101242     return (Dali::BaseHandle *)jarg1;
101243 }
101244
101245 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
101246     return (Dali::BaseHandle *)jarg1;
101247 }
101248
101249 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
101250     return (Dali::BaseHandle *)jarg1;
101251 }
101252
101253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
101254     return (Dali::BaseHandle *)jarg1;
101255 }
101256
101257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
101258     return (Dali::BaseHandle *)jarg1;
101259 }
101260
101261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
101262     return (Dali::BaseHandle *)jarg1;
101263 }
101264
101265 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
101266     return (Dali::Handle *)jarg1;
101267 }
101268
101269 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
101270     return (Dali::Handle *)jarg1;
101271 }
101272
101273 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
101274     return (Dali::BaseHandle *)jarg1;
101275 }
101276
101277 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
101278     return (Dali::BaseHandle *)jarg1;
101279 }
101280
101281 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
101282     return (Dali::Handle *)jarg1;
101283 }
101284
101285 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
101286     return (Dali::BaseHandle *)jarg1;
101287 }
101288
101289 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
101290     return (Dali::Handle *)jarg1;
101291 }
101292
101293 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
101294     return (Dali::GestureDetector *)jarg1;
101295 }
101296
101297 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
101298     return (Dali::Gesture *)jarg1;
101299 }
101300
101301 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
101302     return (Dali::Handle *)jarg1;
101303 }
101304
101305 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
101306     return (Dali::Actor *)jarg1;
101307 }
101308
101309 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
101310     return (Dali::BaseHandle *)jarg1;
101311 }
101312
101313 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
101314     return (Dali::RefObject *)jarg1;
101315 }
101316
101317 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
101318     return (Dali::Actor *)jarg1;
101319 }
101320
101321 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
101322     return (Dali::GestureDetector *)jarg1;
101323 }
101324
101325 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
101326     return (Dali::Gesture *)jarg1;
101327 }
101328
101329 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
101330     return (Dali::GestureDetector *)jarg1;
101331 }
101332
101333 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
101334     return (Dali::Gesture *)jarg1;
101335 }
101336
101337 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
101338     return (Dali::GestureDetector *)jarg1;
101339 }
101340
101341 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
101342     return (Dali::Gesture *)jarg1;
101343 }
101344
101345 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
101346     return (Dali::BaseHandle *)jarg1;
101347 }
101348
101349 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
101350     return (Dali::Handle *)jarg1;
101351 }
101352
101353 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
101354     return (Dali::Handle *)jarg1;
101355 }
101356
101357 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
101358     return (Dali::Handle *)jarg1;
101359 }
101360
101361 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
101362     return (Dali::Image *)jarg1;
101363 }
101364
101365 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
101366     return (Dali::Image *)jarg1;
101367 }
101368
101369 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
101370     return (Dali::Image *)jarg1;
101371 }
101372
101373 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
101374     return (Dali::RefObject *)jarg1;
101375 }
101376
101377 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
101378     return (Dali::Image *)jarg1;
101379 }
101380
101381 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
101382     return (Dali::Image *)jarg1;
101383 }
101384
101385 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
101386     return (Dali::ResourceImage *)jarg1;
101387 }
101388
101389 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
101390     return (Dali::Actor *)jarg1;
101391 }
101392
101393 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
101394     return (Dali::BaseHandle *)jarg1;
101395 }
101396
101397 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_DragAndDropDetector_SWIGUpcast(Dali::DragAndDropDetector *jarg1) {
101398     return (Dali::BaseHandle *)jarg1;
101399 }
101400
101401
101402 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
101403     return (Dali::BaseHandle *)jarg1;
101404 }
101405
101406 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
101407     return (Dali::BaseHandle *)jarg1;
101408 }
101409
101410 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
101411     return (Dali::CustomActorImpl *)jarg1;
101412 }
101413
101414 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
101415     return (Dali::CustomActor *)jarg1;
101416 }
101417
101418 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
101419     return (Dali::BaseHandle *)jarg1;
101420 }
101421
101422 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
101423     return (Dali::Toolkit::Control *)jarg1;
101424 }
101425
101426 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
101427     return (Dali::Toolkit::Control *)jarg1;
101428 }
101429
101430 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
101431     return (Dali::Toolkit::Button *)jarg1;
101432 }
101433
101434 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
101435     return (Dali::Toolkit::Button *)jarg1;
101436 }
101437
101438 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
101439     return (Dali::Toolkit::Button *)jarg1;
101440 }
101441
101442 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
101443     return (Dali::Toolkit::Control *)jarg1;
101444 }
101445
101446 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
101447     return (Dali::Toolkit::Control *)jarg1;
101448 }
101449
101450 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
101451     return (Dali::Toolkit::Control *)jarg1;
101452 }
101453
101454 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
101455     return (Dali::Toolkit::Control *)jarg1;
101456 }
101457
101458 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
101459     return (Dali::Toolkit::Control *)jarg1;
101460 }
101461
101462 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
101463     return (Dali::RefObject *)jarg1;
101464 }
101465
101466 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
101467     return (Dali::Toolkit::Scrollable *)jarg1;
101468 }
101469
101470 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
101471     return (Dali::BaseHandle *)jarg1;
101472 }
101473
101474 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
101475     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
101476 }
101477
101478 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
101479     return (Dali::RefObject *)jarg1;
101480 }
101481
101482 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
101483     return (Dali::Toolkit::Ruler *)jarg1;
101484 }
101485
101486 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
101487     return (Dali::Toolkit::Ruler *)jarg1;
101488 }
101489
101490 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
101491     return (Dali::Toolkit::Scrollable *)jarg1;
101492 }
101493
101494 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
101495     return (Dali::Toolkit::Control *)jarg1;
101496 }
101497
101498
101499 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
101500     return (Dali::Toolkit::Control *)jarg1;
101501 }
101502
101503 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
101504     return (Dali::BaseHandle *)jarg1;
101505 }
101506
101507 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
101508     return (Dali::BaseHandle *)jarg1;
101509 }
101510
101511 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
101512     return (Dali::Toolkit::Control *)jarg1;
101513 }
101514
101515 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
101516     return (Dali::Toolkit::Control *)jarg1;
101517 }
101518
101519 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
101520     return (Dali::Toolkit::Control *)jarg1;
101521 }
101522
101523 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
101524     return (Dali::Toolkit::Control *)jarg1;
101525 }
101526
101527 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
101528     return (Dali::Toolkit::Control *)jarg1;
101529 }
101530
101531 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
101532     return (Dali::Toolkit::Control *)jarg1;
101533 }
101534
101535 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
101536     return (Dali::Toolkit::PageTurnView *)jarg1;
101537 }
101538
101539 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
101540     return (Dali::Toolkit::PageTurnView *)jarg1;
101541 }
101542
101543 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
101544     return (Dali::Toolkit::Button *)jarg1;
101545 }
101546
101547 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
101548     return (Dali::BaseHandle *)jarg1;
101549 }
101550
101551 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
101552     return (Dali::BaseHandle *)jarg1;
101553 }
101554
101555 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
101556     return (Dali::BaseHandle *)jarg1;
101557 }
101558
101559 /*
101560  * Widget binding
101561  */
101562 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
101563     return (Dali::BaseHandle *)jarg1;
101564 }
101565
101566 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
101567     return (Dali::BaseObject *)jarg1;
101568 }
101569
101570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
101571   void * jresult ;
101572   Dali::Widget result;
101573
101574   {
101575     try {
101576       result = Dali::Widget::New();
101577     } catch (std::out_of_range& e) {
101578       {
101579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101580       };
101581     } catch (std::exception& e) {
101582       {
101583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101584       };
101585     } catch (...) {
101586       {
101587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101588       };
101589     }
101590   }
101591   jresult = new Dali::Widget((const Dali::Widget &)result);
101592   return jresult;
101593 }
101594
101595
101596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
101597   void * jresult ;
101598   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
101599   Dali::Widget result;
101600
101601   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101602
101603   if (!arg1) {
101604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
101605     return 0;
101606   }
101607   {
101608     try {
101609       jresult = new Dali::Widget(arg1);
101610     } catch (std::out_of_range& e) {
101611       {
101612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101613       };
101614     } catch (std::exception& e) {
101615       {
101616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101617       };
101618     } catch (...) {
101619       {
101620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101621       };
101622     }
101623   }
101624   return jresult;
101625 }
101626
101627
101628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
101629   void * jresult ;
101630   Dali::Widget *result = 0 ;
101631
101632   {
101633     try {
101634       result = (Dali::Widget *)new Dali::Widget();
101635     } catch (std::out_of_range& e) {
101636       {
101637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101638       };
101639     } catch (std::exception& e) {
101640       {
101641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101642       };
101643     } catch (...) {
101644       {
101645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101646       };
101647     }
101648   }
101649   jresult = (void *)result;
101650   return jresult;
101651 }
101652
101653
101654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
101655   void * jresult ;
101656   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101657   Dali::Widget *arg2 = 0 ;
101658   Dali::Widget *result = 0 ;
101659
101660   arg1 = (Dali::Widget *)jarg1;
101661   arg2 = (Dali::Widget *)jarg2;
101662   if (!arg2) {
101663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
101664     return 0;
101665   }
101666   {
101667     try {
101668       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
101669     } catch (std::out_of_range& e) {
101670       {
101671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101672       };
101673     } catch (std::exception& e) {
101674       {
101675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101676       };
101677     } catch (...) {
101678       {
101679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101680       };
101681     }
101682   }
101683   jresult = (void *)result;
101684   return jresult;
101685 }
101686
101687
101688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
101689   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
101690
101691   arg1 = (Dali::Widget *)jarg1;
101692   {
101693     try {
101694       delete arg1;
101695     } catch (std::out_of_range& e) {
101696       {
101697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101698       };
101699     } catch (std::exception& e) {
101700       {
101701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101702       };
101703     } catch (...) {
101704       {
101705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101706       };
101707     }
101708   }
101709 }
101710
101711
101712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
101713   void * jresult ;
101714   SwigDirector_WidgetImpl* result;
101715   {
101716     try {
101717       result = new SwigDirector_WidgetImpl();
101718     } catch (std::out_of_range& e) {
101719       {
101720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101721       };
101722     } catch (std::exception& e) {
101723       {
101724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101725       };
101726     } catch (...) {
101727       {
101728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101729       };
101730     }
101731   }
101732   jresult = result;
101733   return jresult;
101734 }
101735
101736
101737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
101738   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101739   std::string *arg2 = 0 ;
101740   Dali::Window arg3 ;
101741   Dali::Window *argp3 ;
101742
101743   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101744   if (!jarg2) {
101745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101746     return ;
101747   }
101748   std::string arg2_str(jarg2);
101749   arg2 = &arg2_str;
101750   argp3 = (Dali::Window *)jarg3;
101751   if (!argp3) {
101752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101753     return ;
101754   }
101755   arg3 = *argp3;
101756   {
101757     try {
101758       (arg1)->OnCreate((std::string const &)*arg2,arg3);
101759     } catch (std::out_of_range& e) {
101760       {
101761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101762       };
101763     } catch (std::exception& e) {
101764       {
101765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101766       };
101767     } catch (...) {
101768       {
101769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101770       };
101771     }
101772   }
101773 }
101774
101775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
101776   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101777   std::string *arg2 = 0 ;
101778   Dali::Window arg3 ;
101779   Dali::Window *argp3 ;
101780
101781   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101782   if (!jarg2) {
101783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101784     return ;
101785   }
101786   std::string arg2_str(jarg2);
101787   arg2 = &arg2_str;
101788   argp3 = (Dali::Window *)jarg3;
101789   if (!argp3) {
101790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101791     return ;
101792   }
101793   arg3 = *argp3;
101794   {
101795     try {
101796       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
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
101814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
101815   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101816   std::string *arg2 = 0 ;
101817   Dali::Widget::Termination arg3 ;
101818
101819   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101820   if (!jarg2) {
101821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101822     return ;
101823   }
101824   std::string arg2_str(jarg2);
101825   arg2 = &arg2_str;
101826   arg3 = (Dali::Widget::Termination)jarg3;
101827   {
101828     try {
101829       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
101830     } catch (std::out_of_range& e) {
101831       {
101832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101833       };
101834     } catch (std::exception& e) {
101835       {
101836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101837       };
101838     } catch (...) {
101839       {
101840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101841       };
101842     }
101843   }
101844 }
101845
101846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101847   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101848   std::string *arg2 = 0 ;
101849   Dali::Widget::Termination arg3 ;
101850
101851   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101852   if (!jarg2) {
101853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101854     return ;
101855   }
101856   std::string arg2_str(jarg2);
101857   arg2 = &arg2_str;
101858   arg3 = (Dali::Widget::Termination)jarg3;
101859   {
101860     try {
101861       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
101862     } catch (std::out_of_range& e) {
101863       {
101864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101865       };
101866     } catch (std::exception& e) {
101867       {
101868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101869       };
101870     } catch (...) {
101871       {
101872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101873       };
101874     }
101875   }
101876 }
101877
101878
101879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101880   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101881
101882   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101883   {
101884     try {
101885       (arg1)->OnPause();
101886     } catch (std::out_of_range& e) {
101887       {
101888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101889       };
101890     } catch (std::exception& e) {
101891       {
101892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101893       };
101894     } catch (...) {
101895       {
101896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101897       };
101898     }
101899   }
101900 }
101901
101902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101903   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101904
101905   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101906   {
101907     try {
101908       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101909     } catch (std::out_of_range& e) {
101910       {
101911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101912       };
101913     } catch (std::exception& e) {
101914       {
101915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101916       };
101917     } catch (...) {
101918       {
101919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101920       };
101921     }
101922   }
101923 }
101924
101925
101926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101927   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101928
101929   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101930   {
101931     try {
101932       (arg1)->OnResume();
101933     } catch (std::out_of_range& e) {
101934       {
101935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101936       };
101937     } catch (std::exception& e) {
101938       {
101939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101940       };
101941     } catch (...) {
101942       {
101943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101944       };
101945     }
101946   }
101947 }
101948
101949
101950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101951   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101952
101953   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101954   {
101955     try {
101956       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101957     } catch (std::out_of_range& e) {
101958       {
101959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101960       };
101961     } catch (std::exception& e) {
101962       {
101963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101964       };
101965     } catch (...) {
101966       {
101967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101968       };
101969     }
101970   }
101971 }
101972
101973
101974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101975   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101976   Dali::Window arg2 ;
101977   Dali::Window *argp2 ;
101978
101979   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101980   argp2 = (Dali::Window *)jarg2;
101981   if (!argp2) {
101982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101983     return ;
101984   }
101985   arg2 = *argp2;
101986   {
101987     try {
101988       (arg1)->OnResize(arg2);
101989     } catch (std::out_of_range& e) {
101990       {
101991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101992       };
101993     } catch (std::exception& e) {
101994       {
101995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101996       };
101997     } catch (...) {
101998       {
101999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102000       };
102001     }
102002   }
102003 }
102004
102005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
102006   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102007   Dali::Window arg2 ;
102008   Dali::Window *argp2 ;
102009
102010   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102011   argp2 = (Dali::Window *)jarg2;
102012   if (!argp2) {
102013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
102014     return ;
102015   }
102016   arg2 = *argp2;
102017   {
102018     try {
102019       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
102020     } catch (std::out_of_range& e) {
102021       {
102022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102023       };
102024     } catch (std::exception& e) {
102025       {
102026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102027       };
102028     } catch (...) {
102029       {
102030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102031       };
102032     }
102033   }
102034 }
102035
102036
102037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
102038   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102039   std::string *arg2 = 0 ;
102040   int arg3 ;
102041
102042   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102043   if (!jarg2) {
102044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102045     return ;
102046   }
102047   std::string arg2_str(jarg2);
102048   arg2 = &arg2_str;
102049   arg3 = (int)jarg3;
102050   {
102051     try {
102052       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
102053     } catch (std::out_of_range& e) {
102054       {
102055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102056       };
102057     } catch (std::exception& e) {
102058       {
102059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102060       };
102061     } catch (...) {
102062       {
102063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102064       };
102065     }
102066   }
102067 }
102068
102069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
102070   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102071   std::string *arg2 = 0 ;
102072   int arg3 ;
102073
102074   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102075   if (!jarg2) {
102076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102077     return ;
102078   }
102079   std::string arg2_str(jarg2);
102080   arg2 = &arg2_str;
102081   arg3 = (int)jarg3;
102082   {
102083     try {
102084       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
102085     } catch (std::out_of_range& e) {
102086       {
102087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102088       };
102089     } catch (std::exception& e) {
102090       {
102091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102092       };
102093     } catch (...) {
102094       {
102095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102096       };
102097     }
102098   }
102099 }
102100
102101
102102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
102103   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102104   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102105   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102106
102107   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102108   arg2 = (Dali::SlotObserver *)jarg2;
102109   arg3 = (Dali::CallbackBase *)jarg3;
102110   {
102111     try {
102112       (arg1)->SignalConnected(arg2,arg3);
102113     } catch (std::out_of_range& e) {
102114       {
102115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102116       };
102117     } catch (std::exception& e) {
102118       {
102119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102120       };
102121     } catch (...) {
102122       {
102123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102124       };
102125     }
102126   }
102127 }
102128
102129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102130   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102131   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102132   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102133
102134   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102135   arg2 = (Dali::SlotObserver *)jarg2;
102136   arg3 = (Dali::CallbackBase *)jarg3;
102137   {
102138     try {
102139       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
102140     } catch (std::out_of_range& e) {
102141       {
102142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102143       };
102144     } catch (std::exception& e) {
102145       {
102146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102147       };
102148     } catch (...) {
102149       {
102150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102151       };
102152     }
102153   }
102154 }
102155
102156
102157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
102158   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102159   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102160   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102161
102162   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102163   arg2 = (Dali::SlotObserver *)jarg2;
102164   arg3 = (Dali::CallbackBase *)jarg3;
102165   {
102166     try {
102167       (arg1)->SignalDisconnected(arg2,arg3);
102168     } catch (std::out_of_range& e) {
102169       {
102170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102171       };
102172     } catch (std::exception& e) {
102173       {
102174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102175       };
102176     } catch (...) {
102177       {
102178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102179       };
102180     }
102181   }
102182 }
102183
102184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
102185   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102186   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
102187   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
102188
102189   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102190   arg2 = (Dali::SlotObserver *)jarg2;
102191   arg3 = (Dali::CallbackBase *)jarg3;
102192   {
102193     try {
102194       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
102195     } catch (std::out_of_range& e) {
102196       {
102197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102198       };
102199     } catch (std::exception& e) {
102200       {
102201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102202       };
102203     } catch (...) {
102204       {
102205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102206       };
102207     }
102208   }
102209 }
102210
102211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
102212   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102213   std::string *arg2 = 0 ;
102214
102215   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102216   if (!jarg2) {
102217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102218     return ;
102219   }
102220   std::string arg2_str(jarg2);
102221   arg2 = &arg2_str;
102222   {
102223     try {
102224       (arg1)->SetContentInfo((std::string const &)*arg2);
102225     } catch (std::out_of_range& e) {
102226       {
102227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102228       };
102229     } catch (std::exception& e) {
102230       {
102231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102232       };
102233     } catch (...) {
102234       {
102235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102236       };
102237     }
102238   }
102239 }
102240
102241
102242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
102243   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
102244   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
102245
102246   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
102247   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
102248   {
102249     try {
102250       (arg1)->SetImpl(arg2);
102251     } catch (std::out_of_range& e) {
102252       {
102253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102254       };
102255     } catch (std::exception& e) {
102256       {
102257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102258       };
102259     } catch (...) {
102260       {
102261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102262       };
102263     }
102264   }
102265 }
102266
102267 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) {
102268
102269   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
102270   if (director) {
102271     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
102272   }
102273 }
102274
102275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
102276   void * jresult ;
102277   Dali::Widget *arg1 = 0 ;
102278   SwigDirector_WidgetImpl *result = 0 ;
102279
102280   arg1 = (Dali::Widget *)jarg1;
102281   if (!arg1) {
102282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
102283     return 0;
102284   }
102285   {
102286     try {
102287       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
102288     } catch (std::out_of_range& e) {
102289       {
102290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102291       };
102292     } catch (std::exception& e) {
102293       {
102294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102295       };
102296     } catch (...) {
102297       {
102298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102299       };
102300     }
102301   }
102302
102303   jresult = (void *)result;
102304   return jresult;
102305 }
102306
102307
102308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
102309   void * jresult ;
102310   int *arg1 = (int *) 0 ;
102311   char ***arg2 ;
102312   std::string *arg3 = 0 ;
102313   Dali::WidgetApplication result;
102314   {
102315     int index = 0;
102316     int length = 0;
102317     char *retPtr;
102318     char *nextPtr;
102319     argWidgetC = jarg1;
102320     argWidgetV = new char*[jarg1 + 1];
102321
102322     retPtr = strtok_r( jarg2, " ", &nextPtr);
102323     if( retPtr )
102324     {
102325       length = strlen(retPtr);
102326     }
102327     argWidgetV[index] = new char[length + 1];
102328     if( retPtr )
102329     {
102330       strncpy(argWidgetV[index], retPtr, length);
102331     }
102332     argWidgetV[index][length] = '\0';
102333     index++;
102334
102335     while (index < jarg1)
102336     {
102337       length = 0;
102338       retPtr = strtok_r(NULL, " ", &nextPtr);
102339       if( retPtr )
102340       {
102341         length = strlen(retPtr);
102342       }
102343       argWidgetV[index] = new char[length + 1];
102344       if( retPtr )
102345       {
102346         strncpy(argWidgetV[index], retPtr, length);
102347       }
102348       argWidgetV[index][length] = '\0';
102349       index++;
102350     }
102351
102352     argWidgetV[jarg1] = NULL;
102353     argWidgetC = jarg1;
102354
102355     arg1 = &argWidgetC;
102356     arg2 = &argWidgetV;
102357   }
102358
102359   if (!jarg3) {
102360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102361     return 0;
102362   }
102363   std::string arg3_str(jarg3);
102364   arg3 = &arg3_str;
102365   {
102366     try {
102367       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
102368     } catch (std::out_of_range& e) {
102369       {
102370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102371       };
102372     } catch (std::exception& e) {
102373       {
102374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102375       };
102376     } catch (...) {
102377       {
102378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102379       };
102380     }
102381   }
102382   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
102383
102384   return jresult;
102385 }
102386
102387
102388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
102389   void * jresult ;
102390   Dali::WidgetApplication *result = 0 ;
102391
102392   {
102393     try {
102394       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
102395     } catch (std::out_of_range& e) {
102396       {
102397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102398       };
102399     } catch (std::exception& e) {
102400       {
102401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102402       };
102403     } catch (...) {
102404       {
102405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102406       };
102407     }
102408   }
102409   jresult = (void *)result;
102410   return jresult;
102411 }
102412
102413
102414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
102415   void * jresult ;
102416   Dali::WidgetApplication *arg1 = 0 ;
102417   Dali::WidgetApplication *result = 0 ;
102418
102419   arg1 = (Dali::WidgetApplication *)jarg1;
102420   if (!arg1) {
102421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102422     return 0;
102423   }
102424   {
102425     try {
102426       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
102427     } catch (std::out_of_range& e) {
102428       {
102429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102430       };
102431     } catch (std::exception& e) {
102432       {
102433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102434       };
102435     } catch (...) {
102436       {
102437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102438       };
102439     }
102440   }
102441   jresult = (void *)result;
102442   return jresult;
102443 }
102444
102445
102446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
102447   void * jresult ;
102448   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102449   Dali::WidgetApplication *arg2 = 0 ;
102450   Dali::WidgetApplication *result = 0 ;
102451
102452   arg1 = (Dali::WidgetApplication *)jarg1;
102453   arg2 = (Dali::WidgetApplication *)jarg2;
102454   if (!arg2) {
102455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
102456     return 0;
102457   }
102458   {
102459     try {
102460       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
102461     } catch (std::out_of_range& e) {
102462       {
102463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102464       };
102465     } catch (std::exception& e) {
102466       {
102467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102468       };
102469     } catch (...) {
102470       {
102471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102472       };
102473     }
102474   }
102475   jresult = (void *)result;
102476   return jresult;
102477 }
102478
102479
102480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
102481   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102482
102483   arg1 = (Dali::WidgetApplication *)jarg1;
102484   {
102485     try {
102486       delete arg1;
102487       if( argWidgetV )
102488       {
102489         // free string data
102490         for( int i=0; i < argWidgetC+1; i++)
102491         {
102492           delete [] argWidgetV[i];
102493         }
102494         delete [] argWidgetV;
102495       }
102496     } catch (std::out_of_range& e) {
102497       {
102498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102499       };
102500     } catch (std::exception& e) {
102501       {
102502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102503       };
102504     } catch (...) {
102505       {
102506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102507       };
102508     }
102509   }
102510 }
102511
102512
102513 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
102514 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
102515
102516 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
102517 {
102518   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
102519   return *widget;
102520 }
102521
102522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
102523   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
102524   std::string *arg2 = 0 ;
102525
102526   arg1 = (Dali::WidgetApplication *)jarg1;
102527   if (!jarg2) {
102528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102529     return ;
102530   }
102531   std::string arg2_str(*jarg2);
102532   arg2 = &arg2_str;
102533
102534   if(!_CSharpCreateWidgetFunction)
102535   {
102536     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
102537   }
102538
102539   {
102540     try {
102541       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
102542     } catch (std::out_of_range& e) {
102543       {
102544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102545       };
102546     } catch (std::exception& e) {
102547       {
102548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102549       };
102550     } catch (...) {
102551       {
102552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102553       };
102554     }
102555   }
102556
102557   //Typemap argout in c++ file.
102558   //This will convert c++ string to c# string
102559   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
102560 }
102561
102562
102563 //for PixelBuffer and ImageLoading
102564
102565 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
102566     return (Dali::BaseHandle *)jarg1;
102567 }
102568
102569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
102570   void * jresult ;
102571   unsigned int arg1 ;
102572   unsigned int arg2 ;
102573   Dali::Pixel::Format arg3 ;
102574   Dali::Devel::PixelBuffer result;
102575
102576   arg1 = (unsigned int)jarg1;
102577   arg2 = (unsigned int)jarg2;
102578   arg3 = (Dali::Pixel::Format)jarg3;
102579   {
102580     try {
102581       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
102582     } catch (std::out_of_range& e) {
102583       {
102584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102585       };
102586     } catch (std::exception& e) {
102587       {
102588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102589       };
102590     } catch (...) {
102591       {
102592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102593       };
102594     }
102595   }
102596   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102597   return jresult;
102598 }
102599
102600
102601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
102602   void * jresult ;
102603   Dali::Devel::PixelBuffer *result = 0 ;
102604
102605   {
102606     try {
102607       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
102608     } catch (std::out_of_range& e) {
102609       {
102610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102611       };
102612     } catch (std::exception& e) {
102613       {
102614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102615       };
102616     } catch (...) {
102617       {
102618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102619       };
102620     }
102621   }
102622   jresult = (void *)result;
102623   return jresult;
102624 }
102625
102626
102627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
102628   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102629
102630   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102631   {
102632     try {
102633       delete arg1;
102634     } catch (std::out_of_range& e) {
102635       {
102636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102637       };
102638     } catch (std::exception& e) {
102639       {
102640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102641       };
102642     } catch (...) {
102643       {
102644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102645       };
102646     }
102647   }
102648 }
102649
102650
102651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
102652   void * jresult ;
102653   Dali::Devel::PixelBuffer *arg1 = 0 ;
102654   Dali::Devel::PixelBuffer *result = 0 ;
102655
102656   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102657   if (!arg1) {
102658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102659     return 0;
102660   }
102661   {
102662     try {
102663       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
102664     } catch (std::out_of_range& e) {
102665       {
102666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102667       };
102668     } catch (std::exception& e) {
102669       {
102670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102671       };
102672     } catch (...) {
102673       {
102674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102675       };
102676     }
102677   }
102678   jresult = (void *)result;
102679   return jresult;
102680 }
102681
102682
102683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
102684   void * jresult ;
102685   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102686   Dali::Devel::PixelBuffer *arg2 = 0 ;
102687   Dali::Devel::PixelBuffer *result = 0 ;
102688
102689   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102690   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
102691   if (!arg2) {
102692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
102693     return 0;
102694   }
102695   {
102696     try {
102697       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
102698     } catch (std::out_of_range& e) {
102699       {
102700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102701       };
102702     } catch (std::exception& e) {
102703       {
102704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102705       };
102706     } catch (...) {
102707       {
102708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102709       };
102710     }
102711   }
102712   jresult = (void *)result;
102713   return jresult;
102714 }
102715
102716
102717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
102718   void * jresult ;
102719   Dali::Devel::PixelBuffer *arg1 = 0 ;
102720   Dali::PixelData result;
102721
102722   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102723   if (!arg1) {
102724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
102725     return 0;
102726   }
102727   {
102728     try {
102729       result = Dali::Devel::PixelBuffer::Convert(*arg1);
102730     } catch (std::out_of_range& e) {
102731       {
102732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102733       };
102734     } catch (std::exception& e) {
102735       {
102736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102737       };
102738     } catch (...) {
102739       {
102740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102741       };
102742     }
102743   }
102744   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102745   return jresult;
102746 }
102747
102748
102749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
102750   void * jresult ;
102751   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102752   Dali::PixelData result;
102753
102754   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102755   {
102756     try {
102757       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
102758     } catch (std::out_of_range& e) {
102759       {
102760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102761       };
102762     } catch (std::exception& e) {
102763       {
102764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102765       };
102766     } catch (...) {
102767       {
102768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102769       };
102770     }
102771   }
102772   jresult = new Dali::PixelData((const Dali::PixelData &)result);
102773   return jresult;
102774 }
102775
102776
102777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
102778   void * jresult ;
102779   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102780   unsigned char *result = 0 ;
102781
102782   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102783   {
102784     try {
102785       result = (unsigned char *)(arg1)->GetBuffer();
102786     } catch (std::out_of_range& e) {
102787       {
102788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102789       };
102790     } catch (std::exception& e) {
102791       {
102792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102793       };
102794     } catch (...) {
102795       {
102796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102797       };
102798     }
102799   }
102800   jresult = (void *)result;
102801   return jresult;
102802 }
102803
102804
102805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
102806   unsigned int jresult ;
102807   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102808   unsigned int result;
102809
102810   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102811   {
102812     try {
102813       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
102814     } catch (std::out_of_range& e) {
102815       {
102816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102817       };
102818     } catch (std::exception& e) {
102819       {
102820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102821       };
102822     } catch (...) {
102823       {
102824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102825       };
102826     }
102827   }
102828   jresult = result;
102829   return jresult;
102830 }
102831
102832
102833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
102834   unsigned int jresult ;
102835   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102836   unsigned int result;
102837
102838   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102839   {
102840     try {
102841       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
102842     } catch (std::out_of_range& e) {
102843       {
102844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102845       };
102846     } catch (std::exception& e) {
102847       {
102848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102849       };
102850     } catch (...) {
102851       {
102852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102853       };
102854     }
102855   }
102856   jresult = result;
102857   return jresult;
102858 }
102859
102860
102861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
102862   int jresult ;
102863   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102864   Dali::Pixel::Format result;
102865
102866   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102867   {
102868     try {
102869       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
102870     } catch (std::out_of_range& e) {
102871       {
102872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102873       };
102874     } catch (std::exception& e) {
102875       {
102876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102877       };
102878     } catch (...) {
102879       {
102880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102881       };
102882     }
102883   }
102884   jresult = (int)result;
102885   return jresult;
102886 }
102887
102888
102889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102890   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102891   Dali::Devel::PixelBuffer arg2 ;
102892   float arg3 ;
102893   bool arg4 ;
102894   Dali::Devel::PixelBuffer *argp2 ;
102895
102896   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102897   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102898   if (!argp2) {
102899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102900     return ;
102901   }
102902   arg2 = *argp2;
102903   arg3 = (float)jarg3;
102904   arg4 = jarg4 ? true : false;
102905   {
102906     try {
102907       (arg1)->ApplyMask(arg2,arg3,arg4);
102908     } catch (std::out_of_range& e) {
102909       {
102910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102911       };
102912     } catch (std::exception& e) {
102913       {
102914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102915       };
102916     } catch (...) {
102917       {
102918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102919       };
102920     }
102921   }
102922 }
102923
102924
102925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102926   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102927   Dali::Devel::PixelBuffer arg2 ;
102928   float arg3 ;
102929   Dali::Devel::PixelBuffer *argp2 ;
102930
102931   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102932   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102933   if (!argp2) {
102934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102935     return ;
102936   }
102937   arg2 = *argp2;
102938   arg3 = (float)jarg3;
102939   {
102940     try {
102941       (arg1)->ApplyMask(arg2,arg3);
102942     } catch (std::out_of_range& e) {
102943       {
102944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102945       };
102946     } catch (std::exception& e) {
102947       {
102948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102949       };
102950     } catch (...) {
102951       {
102952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102953       };
102954     }
102955   }
102956 }
102957
102958
102959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102960   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102961   Dali::Devel::PixelBuffer arg2 ;
102962   Dali::Devel::PixelBuffer *argp2 ;
102963
102964   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102965   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102966   if (!argp2) {
102967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102968     return ;
102969   }
102970   arg2 = *argp2;
102971   {
102972     try {
102973       (arg1)->ApplyMask(arg2);
102974     } catch (std::out_of_range& e) {
102975       {
102976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102977       };
102978     } catch (std::exception& e) {
102979       {
102980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102981       };
102982     } catch (...) {
102983       {
102984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102985       };
102986     }
102987   }
102988 }
102989
102990
102991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102992   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102993   float arg2 ;
102994
102995   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102996   arg2 = (float)jarg2;
102997   {
102998     try {
102999       (arg1)->ApplyGaussianBlur(arg2);
103000     } catch (std::out_of_range& e) {
103001       {
103002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103003       };
103004     } catch (std::exception& e) {
103005       {
103006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103007       };
103008     } catch (...) {
103009       {
103010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103011       };
103012     }
103013   }
103014 }
103015
103016
103017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
103018   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103019   uint16_t arg2 ;
103020   uint16_t arg3 ;
103021   uint16_t arg4 ;
103022   uint16_t arg5 ;
103023
103024   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103025   arg2 = (uint16_t)jarg2;
103026   arg3 = (uint16_t)jarg3;
103027   arg4 = (uint16_t)jarg4;
103028   arg5 = (uint16_t)jarg5;
103029   {
103030     try {
103031       (arg1)->Crop(arg2,arg3,arg4,arg5);
103032     } catch (std::out_of_range& e) {
103033       {
103034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103035       };
103036     } catch (std::exception& e) {
103037       {
103038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103039       };
103040     } catch (...) {
103041       {
103042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103043       };
103044     }
103045   }
103046 }
103047
103048
103049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
103050   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
103051   uint16_t arg2 ;
103052   uint16_t arg3 ;
103053
103054   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
103055   arg2 = (uint16_t)jarg2;
103056   arg3 = (uint16_t)jarg3;
103057   {
103058     try {
103059       (arg1)->Resize(arg2,arg3);
103060     } catch (std::out_of_range& e) {
103061       {
103062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103063       };
103064     } catch (std::exception& e) {
103065       {
103066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103067       };
103068     } catch (...) {
103069       {
103070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103071       };
103072     }
103073   }
103074 }
103075
103076
103077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_2(void * jarg1) {
103078   void * jresult ;
103079   Dali::Internal::Adaptor::PixelBuffer *arg1 = (Dali::Internal::Adaptor::PixelBuffer *) 0 ;
103080   Dali::Devel::PixelBuffer *result = 0 ;
103081
103082   arg1 = (Dali::Internal::Adaptor::PixelBuffer *)jarg1;
103083   {
103084     try {
103085       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer(arg1);
103086     } catch (std::out_of_range& e) {
103087       {
103088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103089       };
103090     } catch (std::exception& e) {
103091       {
103092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103093       };
103094     } catch (...) {
103095       {
103096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103097       };
103098     }
103099   }
103100   jresult = (void *)result;
103101   return jresult;
103102 }
103103
103104
103105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103106   void * jresult ;
103107   std::string *arg1 = 0 ;
103108   Dali::ImageDimensions arg2 ;
103109   Dali::FittingMode::Type arg3 ;
103110   Dali::SamplingMode::Type arg4 ;
103111   bool arg5 ;
103112   Dali::ImageDimensions *argp2 ;
103113   Dali::Devel::PixelBuffer result;
103114
103115   if (!jarg1) {
103116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103117     return 0;
103118   }
103119   std::string arg1_str(jarg1);
103120   arg1 = &arg1_str;
103121   argp2 = (Dali::ImageDimensions *)jarg2;
103122   if (!argp2) {
103123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103124     return 0;
103125   }
103126   arg2 = *argp2;
103127   arg3 = (Dali::FittingMode::Type)jarg3;
103128   arg4 = (Dali::SamplingMode::Type)jarg4;
103129   arg5 = jarg5 ? true : false;
103130   {
103131     try {
103132       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103133     } catch (std::out_of_range& e) {
103134       {
103135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103136       };
103137     } catch (std::exception& e) {
103138       {
103139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103140       };
103141     } catch (...) {
103142       {
103143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103144       };
103145     }
103146   }
103147   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103148
103149   return jresult;
103150 }
103151
103152
103153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103154   void * jresult ;
103155   std::string *arg1 = 0 ;
103156   Dali::ImageDimensions arg2 ;
103157   Dali::FittingMode::Type arg3 ;
103158   Dali::SamplingMode::Type arg4 ;
103159   Dali::ImageDimensions *argp2 ;
103160   Dali::Devel::PixelBuffer result;
103161
103162   if (!jarg1) {
103163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103164     return 0;
103165   }
103166   std::string arg1_str(jarg1);
103167   arg1 = &arg1_str;
103168   argp2 = (Dali::ImageDimensions *)jarg2;
103169   if (!argp2) {
103170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103171     return 0;
103172   }
103173   arg2 = *argp2;
103174   arg3 = (Dali::FittingMode::Type)jarg3;
103175   arg4 = (Dali::SamplingMode::Type)jarg4;
103176   {
103177     try {
103178       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
103179     } catch (std::out_of_range& e) {
103180       {
103181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103182       };
103183     } catch (std::exception& e) {
103184       {
103185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103186       };
103187     } catch (...) {
103188       {
103189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103190       };
103191     }
103192   }
103193   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103194
103195   return jresult;
103196 }
103197
103198
103199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103200   void * jresult ;
103201   std::string *arg1 = 0 ;
103202   Dali::ImageDimensions arg2 ;
103203   Dali::FittingMode::Type arg3 ;
103204   Dali::ImageDimensions *argp2 ;
103205   Dali::Devel::PixelBuffer result;
103206
103207   if (!jarg1) {
103208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103209     return 0;
103210   }
103211   std::string arg1_str(jarg1);
103212   arg1 = &arg1_str;
103213   argp2 = (Dali::ImageDimensions *)jarg2;
103214   if (!argp2) {
103215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103216     return 0;
103217   }
103218   arg2 = *argp2;
103219   arg3 = (Dali::FittingMode::Type)jarg3;
103220   {
103221     try {
103222       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
103223     } catch (std::out_of_range& e) {
103224       {
103225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103226       };
103227     } catch (std::exception& e) {
103228       {
103229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103230       };
103231     } catch (...) {
103232       {
103233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103234       };
103235     }
103236   }
103237   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103238
103239   return jresult;
103240 }
103241
103242
103243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
103244   void * jresult ;
103245   std::string *arg1 = 0 ;
103246   Dali::ImageDimensions arg2 ;
103247   Dali::ImageDimensions *argp2 ;
103248   Dali::Devel::PixelBuffer result;
103249
103250   if (!jarg1) {
103251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103252     return 0;
103253   }
103254   std::string arg1_str(jarg1);
103255   arg1 = &arg1_str;
103256   argp2 = (Dali::ImageDimensions *)jarg2;
103257   if (!argp2) {
103258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103259     return 0;
103260   }
103261   arg2 = *argp2;
103262   {
103263     try {
103264       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
103265     } catch (std::out_of_range& e) {
103266       {
103267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103268       };
103269     } catch (std::exception& e) {
103270       {
103271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103272       };
103273     } catch (...) {
103274       {
103275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103276       };
103277     }
103278   }
103279   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103280
103281   return jresult;
103282 }
103283
103284
103285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
103286   void * jresult ;
103287   std::string *arg1 = 0 ;
103288   Dali::Devel::PixelBuffer result;
103289
103290   if (!jarg1) {
103291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103292     return 0;
103293   }
103294   std::string arg1_str(jarg1);
103295   arg1 = &arg1_str;
103296   {
103297     try {
103298       result = Dali::LoadImageFromFile((std::string const &)*arg1);
103299     } catch (std::out_of_range& e) {
103300       {
103301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103302       };
103303     } catch (std::exception& e) {
103304       {
103305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103306       };
103307     } catch (...) {
103308       {
103309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103310       };
103311     }
103312   }
103313   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103314
103315   return jresult;
103316 }
103317
103318
103319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103320   void * jresult ;
103321   std::string *arg1 = 0 ;
103322   Dali::ImageDimensions arg2 ;
103323   Dali::FittingMode::Type arg3 ;
103324   Dali::SamplingMode::Type arg4 ;
103325   bool arg5 ;
103326   Dali::ImageDimensions *argp2 ;
103327   Dali::ImageDimensions result;
103328
103329   if (!jarg1) {
103330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103331     return 0;
103332   }
103333   std::string arg1_str(jarg1);
103334   arg1 = &arg1_str;
103335   argp2 = (Dali::ImageDimensions *)jarg2;
103336   if (!argp2) {
103337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103338     return 0;
103339   }
103340   arg2 = *argp2;
103341   arg3 = (Dali::FittingMode::Type)jarg3;
103342   arg4 = (Dali::SamplingMode::Type)jarg4;
103343   arg5 = jarg5 ? true : false;
103344   {
103345     try {
103346       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103347     } catch (std::out_of_range& e) {
103348       {
103349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103350       };
103351     } catch (std::exception& e) {
103352       {
103353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103354       };
103355     } catch (...) {
103356       {
103357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103358       };
103359     }
103360   }
103361   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103362
103363   return jresult;
103364 }
103365
103366
103367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103368   void * jresult ;
103369   std::string *arg1 = 0 ;
103370   Dali::ImageDimensions arg2 ;
103371   Dali::FittingMode::Type arg3 ;
103372   Dali::SamplingMode::Type arg4 ;
103373   Dali::ImageDimensions *argp2 ;
103374   Dali::ImageDimensions result;
103375
103376   if (!jarg1) {
103377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103378     return 0;
103379   }
103380   std::string arg1_str(jarg1);
103381   arg1 = &arg1_str;
103382   argp2 = (Dali::ImageDimensions *)jarg2;
103383   if (!argp2) {
103384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103385     return 0;
103386   }
103387   arg2 = *argp2;
103388   arg3 = (Dali::FittingMode::Type)jarg3;
103389   arg4 = (Dali::SamplingMode::Type)jarg4;
103390   {
103391     try {
103392       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
103393     } catch (std::out_of_range& e) {
103394       {
103395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103396       };
103397     } catch (std::exception& e) {
103398       {
103399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103400       };
103401     } catch (...) {
103402       {
103403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103404       };
103405     }
103406   }
103407   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103408
103409   return jresult;
103410 }
103411
103412
103413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103414   void * jresult ;
103415   std::string *arg1 = 0 ;
103416   Dali::ImageDimensions arg2 ;
103417   Dali::FittingMode::Type arg3 ;
103418   Dali::ImageDimensions *argp2 ;
103419   Dali::ImageDimensions result;
103420
103421   if (!jarg1) {
103422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103423     return 0;
103424   }
103425   std::string arg1_str(jarg1);
103426   arg1 = &arg1_str;
103427   argp2 = (Dali::ImageDimensions *)jarg2;
103428   if (!argp2) {
103429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103430     return 0;
103431   }
103432   arg2 = *argp2;
103433   arg3 = (Dali::FittingMode::Type)jarg3;
103434   {
103435     try {
103436       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
103437     } catch (std::out_of_range& e) {
103438       {
103439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103440       };
103441     } catch (std::exception& e) {
103442       {
103443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103444       };
103445     } catch (...) {
103446       {
103447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103448       };
103449     }
103450   }
103451   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103452
103453   return jresult;
103454 }
103455
103456
103457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
103458   void * jresult ;
103459   std::string *arg1 = 0 ;
103460   Dali::ImageDimensions arg2 ;
103461   Dali::ImageDimensions *argp2 ;
103462   Dali::ImageDimensions result;
103463
103464   if (!jarg1) {
103465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103466     return 0;
103467   }
103468   std::string arg1_str(jarg1);
103469   arg1 = &arg1_str;
103470   argp2 = (Dali::ImageDimensions *)jarg2;
103471   if (!argp2) {
103472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103473     return 0;
103474   }
103475   arg2 = *argp2;
103476   {
103477     try {
103478       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
103479     } catch (std::out_of_range& e) {
103480       {
103481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103482       };
103483     } catch (std::exception& e) {
103484       {
103485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103486       };
103487     } catch (...) {
103488       {
103489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103490       };
103491     }
103492   }
103493   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103494
103495   return jresult;
103496 }
103497
103498
103499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
103500   void * jresult ;
103501   std::string *arg1 = 0 ;
103502   Dali::ImageDimensions result;
103503
103504   if (!jarg1) {
103505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103506     return 0;
103507   }
103508   std::string arg1_str(jarg1);
103509   arg1 = &arg1_str;
103510   {
103511     try {
103512       result = Dali::GetClosestImageSize((std::string const &)*arg1);
103513     } catch (std::out_of_range& e) {
103514       {
103515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103516       };
103517     } catch (std::exception& e) {
103518       {
103519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103520       };
103521     } catch (...) {
103522       {
103523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103524       };
103525     }
103526   }
103527   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
103528
103529   return jresult;
103530 }
103531
103532
103533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
103534   void * jresult ;
103535   std::string *arg1 = 0 ;
103536   Dali::ImageDimensions arg2 ;
103537   Dali::FittingMode::Type arg3 ;
103538   Dali::SamplingMode::Type arg4 ;
103539   bool arg5 ;
103540   Dali::ImageDimensions *argp2 ;
103541   Dali::Devel::PixelBuffer result;
103542
103543   if (!jarg1) {
103544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103545     return 0;
103546   }
103547   std::string arg1_str(jarg1);
103548   arg1 = &arg1_str;
103549   argp2 = (Dali::ImageDimensions *)jarg2;
103550   if (!argp2) {
103551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103552     return 0;
103553   }
103554   arg2 = *argp2;
103555   arg3 = (Dali::FittingMode::Type)jarg3;
103556   arg4 = (Dali::SamplingMode::Type)jarg4;
103557   arg5 = jarg5 ? true : false;
103558   {
103559     try {
103560       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
103561     } catch (std::out_of_range& e) {
103562       {
103563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103564       };
103565     } catch (std::exception& e) {
103566       {
103567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103568       };
103569     } catch (...) {
103570       {
103571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103572       };
103573     }
103574   }
103575   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103576
103577   return jresult;
103578 }
103579
103580
103581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
103582   void * jresult ;
103583   std::string *arg1 = 0 ;
103584   Dali::ImageDimensions arg2 ;
103585   Dali::FittingMode::Type arg3 ;
103586   Dali::SamplingMode::Type arg4 ;
103587   Dali::ImageDimensions *argp2 ;
103588   Dali::Devel::PixelBuffer result;
103589
103590   if (!jarg1) {
103591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103592     return 0;
103593   }
103594   std::string arg1_str(jarg1);
103595   arg1 = &arg1_str;
103596   argp2 = (Dali::ImageDimensions *)jarg2;
103597   if (!argp2) {
103598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103599     return 0;
103600   }
103601   arg2 = *argp2;
103602   arg3 = (Dali::FittingMode::Type)jarg3;
103603   arg4 = (Dali::SamplingMode::Type)jarg4;
103604   {
103605     try {
103606       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
103607     } catch (std::out_of_range& e) {
103608       {
103609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103610       };
103611     } catch (std::exception& e) {
103612       {
103613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103614       };
103615     } catch (...) {
103616       {
103617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103618       };
103619     }
103620   }
103621   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103622
103623   return jresult;
103624 }
103625
103626
103627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
103628   void * jresult ;
103629   std::string *arg1 = 0 ;
103630   Dali::ImageDimensions arg2 ;
103631   Dali::FittingMode::Type arg3 ;
103632   Dali::ImageDimensions *argp2 ;
103633   Dali::Devel::PixelBuffer result;
103634
103635   if (!jarg1) {
103636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103637     return 0;
103638   }
103639   std::string arg1_str(jarg1);
103640   arg1 = &arg1_str;
103641   argp2 = (Dali::ImageDimensions *)jarg2;
103642   if (!argp2) {
103643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103644     return 0;
103645   }
103646   arg2 = *argp2;
103647   arg3 = (Dali::FittingMode::Type)jarg3;
103648   {
103649     try {
103650       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
103651     } catch (std::out_of_range& e) {
103652       {
103653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103654       };
103655     } catch (std::exception& e) {
103656       {
103657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103658       };
103659     } catch (...) {
103660       {
103661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103662       };
103663     }
103664   }
103665   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103666
103667   return jresult;
103668 }
103669
103670
103671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
103672   void * jresult ;
103673   std::string *arg1 = 0 ;
103674   Dali::ImageDimensions arg2 ;
103675   Dali::ImageDimensions *argp2 ;
103676   Dali::Devel::PixelBuffer result;
103677
103678   if (!jarg1) {
103679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103680     return 0;
103681   }
103682   std::string arg1_str(jarg1);
103683   arg1 = &arg1_str;
103684   argp2 = (Dali::ImageDimensions *)jarg2;
103685   if (!argp2) {
103686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
103687     return 0;
103688   }
103689   arg2 = *argp2;
103690   {
103691     try {
103692       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
103693     } catch (std::out_of_range& e) {
103694       {
103695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103696       };
103697     } catch (std::exception& e) {
103698       {
103699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103700       };
103701     } catch (...) {
103702       {
103703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103704       };
103705     }
103706   }
103707   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103708
103709   return jresult;
103710 }
103711
103712
103713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
103714   void * jresult ;
103715   std::string *arg1 = 0 ;
103716   Dali::Devel::PixelBuffer result;
103717
103718   if (!jarg1) {
103719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103720     return 0;
103721   }
103722   std::string arg1_str(jarg1);
103723   arg1 = &arg1_str;
103724   {
103725     try {
103726       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
103727     } catch (std::out_of_range& e) {
103728       {
103729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103730       };
103731     } catch (std::exception& e) {
103732       {
103733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103734       };
103735     } catch (...) {
103736       {
103737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103738       };
103739     }
103740   }
103741   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
103742
103743   return jresult;
103744 }
103745
103746
103747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetMaxTextureSize(unsigned int jarg1) {
103748   unsigned int arg1 ;
103749
103750   arg1 = (unsigned int)jarg1;
103751   {
103752     try {
103753       Dali::SetMaxTextureSize(arg1);
103754     } catch (std::out_of_range& e) {
103755       {
103756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103757       };
103758     } catch (std::exception& e) {
103759       {
103760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103761       };
103762     } catch (...) {
103763       {
103764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103765       };
103766     }
103767   }
103768 }
103769
103770
103771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetMaxTextureSize() {
103772   unsigned int jresult ;
103773   unsigned int result;
103774
103775   {
103776     try {
103777       result = (unsigned int)Dali::GetMaxTextureSize();
103778     } catch (std::out_of_range& e) {
103779       {
103780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103781       };
103782     } catch (std::exception& e) {
103783       {
103784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103785       };
103786     } catch (...) {
103787       {
103788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103789       };
103790     }
103791   }
103792   jresult = result;
103793   return jresult;
103794 }
103795
103796
103797 #ifdef __cplusplus
103798 }
103799 #endif
103800